إذا كنت تدير سيرفر Windows أو تطور برنامجاً يعمل عليه، فغالب الظن أنك قابلت أحد هذه المواقف: مدير المهام Task Manager يقول إن الذاكرة مستهلكة بنسبة 90% مع أن مجموع ما تستهلكه البرامج في قائمة العمليات لا يقترب من هذا الرقم، أو برنامج يتوقف برسالة نفاد الذاكرة Out of Memory بينما يقول الجهاز نفسه إن لديه عشرات الجيجابايتات المتاحة، أو زميل ينصحك بتعطيل ملف الصفحات Pagefile لأن الجهاز فيه ذاكرة كثيرة، أو أداة تعدك بأن «تنظف الذاكرة» بضغطة زر فينخفض الرقم فعلاً ثم يصبح الجهاز أبطأ. وكل هذه المواقف لها سبب واحد: Windows لا يعد الذاكرة برقم واحد، وإنما بعدة أرقام لكل منها معنى مختلف، والرقم الذي تنظر إليه في الغالب ليس الرقم الذي يقرر هل سينجح طلب الذاكرة التالي أم لا.
وهذا المقال من مرحلة Windows من الداخل، ويأتي بعد مقال الذاكرة الافتراضية Virtual Memory وجداول الصفحات الذي شرح الصفحة Page والإطار Frame وجدول الصفحات Page Table وخطأ الصفحة Page Fault على Linux، فلن نعيد هذه الأساسيات هنا، وإنما نأخذها كما هي وننظر إلى ما يفعله مدير الذاكرة Memory Manager في Windows فوقها: كيف يفرق بين العنوان المحجوز والعنوان المثبت، وأين تذهب الصفحة عندما تخرج من ذاكرة العملية، ومتى يحتاج ملف الصفحات، ومن أين يأتي الرقم الذي يرفض عنده النظام طلبك. وكل ذلك بتجارب صغيرة بلغة C نشغلها على جهاز Windows 11 حقيقي بصلاحيات مستخدم عادي، ونقرأ مخرجها سطراً سطراً.
دليلالعمليات والخيوط وكائنات Job في Windowsنقيس بلغة C على Windows 11 كيف يختار المجدول الخيط الذي يعمل، ولماذا تكفي درجة أولوية واحدة لتجويع برنامج، وكيف تضع كائنات Job سقفاً للمعالج وتنهي شجرة العمليات كلها.
دليلالمقابض Handles والكائنات Objects في Windowsنفتح الرقم الذي يعطيه Windows لبرنامجك عند كل فتح ونرى ما خلفه بلغة C وWinObj على Windows 11 دون صلاحيات المدير: أين تعيش الأسماء، ومتى يموت الكائن، ومن يحق له فتحه، وكم يكلف المقبض الذي لا يغلق.
دليلرموز الأمان Tokens وقوائم ACL والتحكم UAC في Windowsنقرأ رمز الأمان الذي يحمله كل برنامج على Windows 11 ونستعمله ببرنامج C دون رفع الصلاحيات، لنفهم لماذا يرفض Windows حساب المدير، وكيف يمنع مستوى Low الكتابة، وكيف تقرر قوائم ACL.وسوف نناقش في هذا المقال ما يلي:
- من هو مدير الذاكرة داخل النواة Kernel، وما الخيوط Threads والجداول التي يعمل بها.
- مساحة العناوين Address Space لكل عملية، ولماذا تحجز الذاكرة بقطع من 64 KB.
- الفرق بين الحجز Reserve والتثبيت Commit، وكيف تحجز 100 TB في جزء من الميلي ثانية دون أن يتغير شيء.
- خطأ الصفحة عند أول لمسة، ومجموعة العمل Working Set، وماذا يحدث عندما تقلمها Trimming.
- قوائم الصفحات في الذاكرة: Modified وStandby وFree وZero، ولماذا «المتاحة» لا تعني «الفارغة».
- ملف الصفحات Pagefile وحد التثبيت Commit Limit، وما رأيناه عندما طلبنا أكثر من الحد.
- الأقسام Sections والملفات المعروضة في الذاكرة Memory-Mapped Files بين عمليتين، والنسخ عند الكتابة Copy-on-Write.
- حد الذاكرة داخل كائن Job، والصفحات الكبيرة Large Pages، وخريطة الذاكرة في VMMap.
- الأخطاء الشائعة، وجدول قرار، وتدريب عملي.
لماذا لا يكفي رقم واحد للذاكرة؟
لنأخذ مثالاً من العمل اليومي: خدمة مكتوبة بـ .NET أو Java تعمل على سيرفر Windows فيه 16 GB، ويشتكي الفريق من أنها «تأكل الذاكرة». تفتح مدير المهام فتجد في عمود الذاكرة رقماً، وتفتح Process Explorer فتجد عمودين: Private Bytes وWorking Set، والرقمان مختلفان جداً، وفي تبويب الأداء تجد رقماً ثالثاً اسمه Committed بجانبه رقم أكبر منه. فأي رقم هو استهلاك الخدمة؟ والإجابة أن كل رقم يجيب عن سؤال مختلف:
- Working Set: كم صفحة من صفحات العملية موجودة الآن في الذاكرة الفعلية RAM، ويستطيع المعالج أن يصل إليها دون أي عمل إضافي من النظام.
- Private Bytes: كم من الذاكرة الخاصة بالعملية «وعدها» النظام بها، سواء كانت الآن في RAM أو في ملف الصفحات أو لم تلمس أصلاً.
- Commit Charge للجهاز: مجموع هذه الوعود لكل العمليات والنواة معاً، ويقارن بحد التثبيت Commit Limit الذي يساوي حجم RAM مع حجم ملفات الصفحات.
وقد شرحنا في مقال Process Explorer أن ارتفاع Private Bytes ساعة بعد ساعة علامة تسرب في الذاكرة Memory Leak، وفي هذا المقال سوف نرى من الداخل لماذا يتحرك كل رقم من هذه الأرقام، ومتى يتحرك أحدها والآخر ثابت، لأن هذا هو ما تحتاجه عندما تقرأ رسم الذاكرة لخدمة حقيقية. والصورة التالية تجمع أرقام المختبر الذي سوف نشغله، وسوف نعود إلى كل سطر منها بالتفصيل:

من هو مدير الذاكرة Memory Manager؟
مدير الذاكرة جزء من النواة نفسها، أي من الملف ntoskrnl.exe، وهو أحد المديرين الذين يسميهم Windows بالتنفيذي Executive، وقد ذكرناه بالاسم في مقال كيف يعمل Windows من الداخل مع مدير الإدخال والإخراج ومدير الكائنات. وعمله في جملة واحدة: أن يعطي كل عملية وهم أنها تملك مساحة عناوين كبيرة خاصة بها، وأن يقرر في كل لحظة أي صفحات هذه المساحة تستحق أن تكون في RAM، وأيها يمكن أن ينتظر على القرص، وأن يعيد الصفحة إلى مكانها عندما تحتاجها العملية مرة أخرى. ولكي يفعل ذلك يحتفظ بعدة جداول، أهمها:
- شجرة واصفات العناوين الافتراضية Virtual Address Descriptors، واختصاراً VAD: لكل عملية شجرة تسجل كل مدى من العناوين حجزته، ونوعه وحمايته Protection، وهل هو ذاكرة خاصة أو عرض لملف. وهذه الشجرة هي التي تقرؤها الدالة
VirtualQueryوالأداة VMMap. - جداول الصفحات Page Tables لكل عملية، وهي ما يقرؤه المعالج نفسه ليترجم العنوان الافتراضي إلى عنوان فعلي، كما شرحنا في مقال الذاكرة الافتراضية.
- قاعدة بيانات أرقام الإطارات Page Frame Number Database، واختصاراً PFN Database: جدول فيه سجل لكل صفحة فعلية في RAM، يقول لمن هي، وفي أي قائمة هي الآن: هل هي في Working Set لعملية، أو في قائمة الانتظار Standby، أو القائمة المعدلة Modified، أو قائمة الصفحات الحرة Free أو المصفرة Zero.
ومع الجداول مجموعة من خيوط النظام التي تعمل في العملية System برقم 4: مدير مجموعات العمل Working Set Manager الذي يقرر متى يأخذ صفحات من العمليات عندما تنقص الذاكرة، والكاتب Modified Page Writer الذي يكتب الصفحات المعدلة إلى ملف الصفحات، والكاتب Mapped Page Writer الذي يكتب صفحات الملفات المعروضة إلى ملفاتها، وخيط تصفير الصفحات Zero Page Thread الذي يملأ الصفحات الحرة بالأصفار قبل أن تعطى لأي عملية، لأن Windows لا يسمح أبداً بأن ترى عملية بقايا بيانات عملية أخرى. وكل هذا مشروح بالتفصيل في الفصل الخامس من الجزء الأول من كتاب Windows Internals في طبعته السابعة (Yosifovich وIonescu وRussinovich وSolomon)، وصفحة الكتاب في موقع Sysinternals، والمقال هنا يمر على هذه الأجزاء بالقدر الذي تراه في المختبر، والكتاب هو المرجع لمن يريد كل التفاصيل.
تجهيز المختبر Lab
المختبر برنامج واحد بلغة C اسمه mem.exe، وله عدة أوضاع Modes، كل وضع يجرب جانباً واحداً من مدير الذاكرة ثم يطبع الأرقام. ولا نحتاج إلى تثبيت أي مترجم على Windows، فالبناء يتم بمترجم MinGW-w64 GCC داخل Container مؤقت من Alpine يحذف نفسه بعد الانتهاء، كما في بقية مقالات المسار:
docker run --rm -v "%cd%:/src" -w /src alpine:3.22 sh build.shوالملف build.sh يثبت المترجم داخل الـ Container ثم يبني البرنامج ويربطه بالمكتبة psapi التي فيها دوال قراءة ذاكرة العملية:
#!/bin/sh
# Builds mem.exe with the MinGW-w64 cross compiler in a throw-away Alpine container (nothing is installed on Windows):
# docker run --rm -v "%cd%:/src" -w /src alpine:3.22 sh build.sh
set -e
command -v x86_64-w64-mingw32-gcc >/dev/null || apk add -q mingw-w64-gcc >/dev/null
x86_64-w64-mingw32-gcc --version | head -1
mkdir -p build
x86_64-w64-mingw32-gcc -municode -O1 -Wall -o build/mem.exe mem.c -lpsapi
ls -l buildوفي كل وضع يطبع البرنامج بعد كل خطوة سطراً واحداً من الدالة stats، وهي الدالة التي سوف تقرأ مخرجها في كل تجربة، فلنفهمها مرة واحدة:
static PROCESS_MEMORY_COUNTERS_EX pm(void) {
PROCESS_MEMORY_COUNTERS_EX c = { sizeof c }; GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS *)&c, sizeof c); return c;
}
static DWORD lastFaults;
static void stats(const wchar_t *label) {
PROCESS_MEMORY_COUNTERS_EX c = pm(); PERFORMANCE_INFORMATION p = { sizeof p }; GetPerformanceInfo(&p, sizeof p);
out(L" %-34ls private %8.1f MB | working set %8.1f MB | page faults %8lu (+%lu) | system commit %6.2f / %6.2f GB\n", label,
c.PrivateUsage / MB, c.WorkingSetSize / MB, c.PageFaultCount, c.PageFaultCount - lastFaults,
p.CommitTotal * (double)p.PageSize / (MB * 1024), p.CommitLimit * (double)p.PageSize / (MB * 1024));
lastFaults = c.PageFaultCount;
}وفي الدالة أعلاه لاحظ التالي:
- الدالة GetProcessMemoryInfo تملأ البنية PROCESS_MEMORY_COUNTERS_EX، ومنها نأخذ ثلاثة أرقام:
PrivateUsageوهو نفسه Private Bytes، وWorkingSetSize، وPageFaultCountوهو عدد أخطاء الصفحة منذ بدأت العملية. والسطر يطبع العدد ومعه الزيادة منذ السطر السابق بين قوسين. - الدالة
GetPerformanceInfoتملأ البنية PERFORMANCE_INFORMATION بأرقام الجهاز كله، ومنها نأخذCommitTotalوCommitLimit، أي التثبيت الحالي للجهاز وحده الأعلى، وكلاهما بعدد الصفحات فنضربه في حجم الصفحة.
أما الدالة touch فتلمس بايتاً واحداً في كل صفحة من 4 KB، قراءة أو كتابة، وتعيد الزمن بالميلي ثانية، وهي الأداة التي نستعملها لنقول للنظام «الآن أريد هذه الصفحات فعلاً»:
static double touch(char *p, SIZE_T n, int write) { // one access per 4 KB page
double t = now_ms(); volatile char s = 0;
for (SIZE_T i = 0; i < n; i += 4096) { if (write) p[i] = (char)i; else s += p[i]; }
(void)s; return now_ms() - t;
}ثم يشغل السكربت run.ps1 في Windows PowerShell 5.1 الملفات المرقمة بالترتيب، وكل ملف يكتب مخرجه في ملف out-*.txt بجانبه بعد أن يستبدل اسم المستخدم واسم الجهاز ومسار مجلد المختبر بأسماء عامة مثل C:\lab:
powershell -NoProfile -ExecutionPolicy Bypass -File run.ps1والسكربت لا يحتاج صلاحيات المدير Administrator، ولا يغير شيئاً في السجل Registry، ويستدعي SetErrorMode حتى لا تظهر نافذة خطأ عندما تسقط إحدى التجارب برنامجها عمداً، وكل ما ينشئه في مجلد واحد داخل %TEMP% يحذفه السكربت الأخير. وهذه بيئة التشغيل كما طبعها السكربت الأول:
OS : Microsoft Windows 11 Pro (build 26100.9711)
PowerShell: 5.1.26100.9711
Elevated : False
RAM : 63.9 GB
Pagefile automatically managed: True
Name AllocatedBaseSize CurrentUsage PeakUsage
---- ----------------- ------------ ---------
F:\pagefile.sys 49152 2656 13836
> mem.exe info
page size 4096 bytes
allocation granularity 65536 bytes
lowest user address 0000000000010000
highest user address 00007FFFFFFEFFFF (128.0 TB of user address space)
large page minimum 2097152 bytes
physical memory 65404 MB total, 31419 MB available
system cache 21964 MB
commit charge 66733 MB now, 114556 MB limit, 238339 MB peak
kernel paged pool 3895 MB, nonpaged pool 1948 MB
processes 538, threads 7266, handles 1804871
[exit code 0 = 0x00000000]وفي المخرج أعلاه لاحظ التالي:
- الجهاز فيه 63.9 GB من الذاكرة، وملف صفحات واحد على القرص
F:بحجم 49,152 MB، أي 48 GB، والنظام هو الذي يدير حجمه، لأنAutomaticManagedPagefileقيمتهTrue. ولاحظ أن الملف ليس على قرص النظام، وهذا ممكن ومدعوم، وسوف نرى أن هذا التفصيل كان له أثر في إحدى التجارب. - حجم الصفحة 4096 بايت، ودقة الحجز Allocation Granularity هي 65536 بايت، أي 64 KB، وسوف نشرح الفرق بينهما في القسم التالي.
- مساحة العناوين للبرنامج تبدأ من
0x10000وتنتهي عند0x7FFFFFFEFFFF، أي 128 TB لكل عملية 64-bit، وهي مساحة لا علاقة لها بحجم RAM الموجود. - سطر
commit chargeيقول إن التثبيت الحالي للجهاز 66,733 MB من حد قدره 114,556 MB، أي حوالي 65 GB من 111.9 GB، وهذا الحد هو بالضبط RAM مع ملف الصفحات تقريباً. أما الرقم الثالث، أعلى تثبيت وصل إليه الجهاز منذ أقلع، فهو 238,339 MB، أكبر من الحد نفسه بكثير، وهذا ليس خطأ في البرنامج، وإنما أثر تجربة سابقة سوف نحكيها في قسم المشكلة التي قابلتنا. - ذاكرة النواة: مجمع الذاكرة القابل للتصفح Paged Pool حوالي 3.9 GB، والمجمع غير القابل للتصفح Nonpaged Pool حوالي 1.9 GB، والثاني هو الذاكرة التي يجب أن تبقى في RAM دائماً لأن التعريفات Drivers تصل إليها في لحظات لا يسمح فيها بخطأ صفحة.
مساحة العناوين Address Space: 128 TB لكل عملية
كل عملية في Windows 64-bit ترى مساحة عناوين خاصة بها حجمها 128 TB للجزء الخاص بالمستخدم User Mode، ومثلها تقريباً للنواة في الجزء الأعلى الذي لا تستطيع العملية أن تصل إليه. وهذه المساحة ليست ذاكرة، وإنما أرقام عناوين فقط، وكل صفحة فيها في واحدة من ثلاث حالات تسميها Microsoft في صفحة حالات الصفحة Page State:
- حرة Free: لا يوجد شيء في هذا العنوان، وأي محاولة للقراءة أو الكتابة فيه تنتهي بخطأ وصول للذاكرة Access Violation.
- محجوزة Reserved: العملية سجلت هذا المدى باسمها حتى لا يأخذه جزء آخر من البرنامج، ولكن لا توجد خلفه أي ذاكرة، والوصول إليه ما زال خطأ وصول.
- مثبتة Committed: النظام ضمن أن لهذه الصفحات مكاناً، إما في RAM أو في ملف الصفحات، وحسبها على حد التثبيت، والعملية تستطيع أن تقرأها وتكتبها حسب الحماية التي طلبتها.

لماذا تحجز الذاكرة بقطع من 64 KB؟
لاحظت في مخرج الإعداد أن حجم الصفحة 4 KB، ولكن دقة الحجز 64 KB. وهذا يعني أن عنوان بداية أي حجز بالدالة VirtualAlloc يجب أن يكون من مضاعفات 64 KB، حتى لو طلبت صفحة واحدة. والسبب تاريخي شرحه Raymond Chen في مقاله Why is address space allocation granularity 64KB?: المعالج Alpha AXP، وهو من المعالجات التي دعمها Windows NT في بدايته، كان يبني العنوان الكامل من نصفين كل منهما 16 بت، فكان تعديل العناوين عند نقل الكود Relocation أبسط بكثير إذا بدأت كل كتلة على حد 64 KB، فاختار الفريق هذه الدقة لكل المعالجات حتى يبقى السلوك واحداً، وبقيت القيمة إلى اليوم. وفي الجزء الأخير من تجربة الحجز نرى أثرها مباشرة:
reserve 4 KB at 0x0000020000001000 -> 0000020000000000 (rounded down to 64 KB)
VirtualQuery 4 KB alloc base 00000127A5020000 size 0.0 MB state MEM_COMMIT protect 0x04
VirtualQuery after it base 00000127A5021000 size 0.1 MB state MEM_FREE protect 0x01طلبنا حجز 4 KB عند العنوان 0x0000020000001000، فأعاد النظام العنوان 0x0000020000000000، أي قرب البداية إلى أقرب حد 64 KB تحتها. وفي السطرين التاليين حجزنا صفحة واحدة في أي مكان، فكانت الصفحة الأولى MEM_COMMIT، والمدى بعدها مباشرة MEM_FREE بحجم 0.1 MB تقريباً، أي باقي الـ 64 KB التي لا يستطيع أحد أن يحجزها لأن بدايتها ليست على حد صحيح. وهذا الجزء الضائع هو ما تسميه VMMap بالنوع Unusable كما سوف نرى في آخر المقال، ولذلك لا تقم بحجز صفحات صغيرة كثيرة بالدالة VirtualAlloc، والطريقة الصحيحة أن تحجز مدى كبيراً مرة واحدة ثم تقسمه بنفسك، أو أن تستعمل الكومة Heap عبر malloc أو HeapAlloc التي تفعل ذلك نيابة عنك.
الحجز Reserve والتثبيت Commit
الدالة VirtualAlloc هي أدنى طريقة يطلب بها برنامج في وضع المستخدم ذاكرة من Windows، وكل ما فوقها، من malloc في C إلى الـ Garbage Collector في .NET وJava، يستعملها في النهاية. والمعامل الذي يهمنا هو نوع الطلب: MEM_RESERVE للحجز، وMEM_COMMIT للتثبيت، أو الاثنين معاً. وتشرح Microsoft في صفحة Reserving and Committing Memory لماذا يوجد الفرق: برنامج يحتاج مصفوفة قد تكبر إلى حجم كبير، ولكنه لا يعرف كم سيحتاج فعلاً، يحجز المدى كله ليبقى متصلاً، ثم يثبت منه ما يحتاجه فقط مع الوقت، فلا يدفع ثمن ما لم يستعمله. وهذا بالضبط ما تفعله الكومة والـ Stack لكل خيط: يحجز Windows للـ Stack مدى يحدد حجمه ملف البرنامج نفسه، 1 MB في برامج Visual C++ و2 MB في برنامجنا المبني بـ MinGW، ويثبت منه صفحات قليلة، ويزيد التثبيت عندما ينمو الـ Stack.
والوضع reserve في البرنامج يجرب ذلك خطوة خطوة:
static void reserve(void) {
SIZE_T GB = 1024ull * 1024 * 1024;
stats(L"start");
char *r = VirtualAlloc(NULL, 8 * GB, MEM_RESERVE, PAGE_NOACCESS);
out(L"reserve 8 GB -> %p\n", r); stats(L"after reserve 8 GB"); query(L"reserved", r);
char *c = VirtualAlloc(r, 1 * GB, MEM_COMMIT, PAGE_READWRITE);
out(L"commit first 1 GB of it -> %p\n", c); stats(L"after commit 1 GB"); query(L"committed", r); query(L"rest", r + GB);
double t = touch(c, 256 * 1024 * 1024, 1);
out(L"write one byte in each page of 256 MB: %.1f ms\n", t); stats(L"after touching 256 MB");
t = touch(c, 256 * 1024 * 1024, 1);
out(L"write the same 256 MB again: %.1f ms\n", t); stats(L"after touching it again");
VirtualFree(c, 256 * 1024 * 1024, MEM_DECOMMIT); stats(L"after decommit of 256 MB");
VirtualFree(r, 0, MEM_RELEASE); stats(L"after release of all");والمخرج سوف يكون كما يلي:
> mem.exe reserve
start private 0.8 MB | working set 4.3 MB | page faults 1153 (+1) | system commit 65.01 / 111.87 GB
reserve 8 GB -> 00000127A5440000
after reserve 8 GB private 0.8 MB | working set 4.4 MB | page faults 1176 (+23) | system commit 65.01 / 111.87 GB
VirtualQuery reserved base 00000127A5440000 size 8192.0 MB state MEM_RESERVE protect 0x00
commit first 1 GB of it -> 00000127A5440000
after commit 1 GB private 1026.8 MB | working set 4.4 MB | page faults 1690 (+514) | system commit 66.02 / 111.87 GB
VirtualQuery committed base 00000127A5440000 size 1024.0 MB state MEM_COMMIT protect 0x04
VirtualQuery rest base 00000127E5440000 size 7168.0 MB state MEM_RESERVE protect 0x00
write one byte in each page of 256 MB: 35.7 ms
after touching 256 MB private 1026.8 MB | working set 260.4 MB | page faults 67226 (+65536) | system commit 66.02 / 111.87 GB
write the same 256 MB again: 0.8 ms
after touching it again private 1026.8 MB | working set 260.4 MB | page faults 67226 (+0) | system commit 66.02 / 111.87 GB
after decommit of 256 MB private 770.3 MB | working set 4.4 MB | page faults 67228 (+2) | system commit 65.77 / 111.87 GB
after release of all private 0.8 MB | working set 4.4 MB | page faults 67228 (+0) | system commit 65.02 / 111.87 GBوفي المخرج أعلاه لاحظ التالي:
- بعد حجز 8 GB لم يتغير شيء تقريباً: Private بقي 0.8 MB، وWorking Set زاد 0.1 MB، وتثبيت الجهاز بقي 65.01 GB كما هو. والدالة
VirtualQueryتقول إن المدى كله بحجم 8192 MB في الحالةMEM_RESERVEوحمايته صفر، أي لا يوجد ما يحمى بعد. أما الزيادة الصغيرة في أخطاء الصفحة (23) فهي من بنية الشجرة VAD وكود البرنامج نفسه، لا من المدى المحجوز. - بعد تثبيت أول 1 GB ارتفع Private إلى 1026.8 MB، وتثبيت الجهاز من 65.01 إلى 66.02 GB، بينما بقي Working Set عند 4.4 MB. وهذه أهم ملاحظة في المقال: التثبيت وعد لا يأخذ صفحة واحدة من RAM، ولكنه يحسب كاملاً على حد التثبيت للجهاز كله، ولذلك يظهر في Private Bytes فوراً. و
VirtualQueryتقول الآن إن أول 1024 MB في الحالةMEM_COMMITبحماية0x04، وهي القيمةPAGE_READWRITE، وإن الباقي، 7168 MB، ما زال محجوزاً فقط. - بعد كتابة بايت في كل صفحة من 256 MB حدث 65,536 خطأ صفحة بالضبط، وهو عدد الصفحات في 256 MB (256 × 1024 ÷ 4)، وزاد Working Set إلى 260.4 MB، واستغرق ذلك 35.7 ms. أما Private وتثبيت الجهاز فلم يتغيرا، لأن الوعد كان قد حسب مسبقاً.
- الكتابة نفسها مرة ثانية استغرقت 0.8 ms دون أي خطأ صفحة، أي أسرع بأكثر من 40 مرة، لأن الصفحات أصبحت في Working Set والمعالج يصل إليها مباشرة.
- إلغاء التثبيت Decommit لأول 256 MB بالدالة
VirtualFreeمعMEM_DECOMMITأعاد Private إلى 770.3 MB وWorking Set إلى 4.4 MB، وتحرير المدى كله معMEM_RELEASEأعاد كل الأرقام إلى البداية.
100 TB في جزء من الميلي ثانية
إذا كان الحجز لا يكلف شيئاً، فما الحد؟ الوضع huge يحجز 100 TB مرة واحدة، أي أكثر من 1500 ضعف ذاكرة الجهاز، ثم يثبت صفحة واحدة في منتصفها ويكتب فيها:
> mem.exe huge
start private 0.8 MB | working set 4.3 MB | page faults 1149 (+1) | system commit 65.02 / 111.87 GB
reserve 100 TB -> 000001EACA1A0000 in 0.01 ms
after reserve 100 TB private 0.8 MB | working set 4.4 MB | page faults 1174 (+25) | system commit 65.02 / 111.87 GB
commit one page in the middle -> 000033EACA1A0000
after writing it private 0.8 MB | working set 4.4 MB | page faults 1182 (+8) | system commit 65.02 / 111.87 GB
[exit code 0 = 0x00000000]الحجز نجح في 0.01 ms، ولم يتغير Private ولا تثبيت الجهاز، لأن الحجز ليس إلا عقدة جديدة في شجرة VAD. ثم ثبتنا صفحة عند العنوان 0x000033EACA1A0000، أي بعد 50 TB من بداية الحجز، وكتبنا فيها فحدثت ثمانية أخطاء صفحة: واحد للصفحة نفسها، والباقي للصفحات التي يحتاجها مدير الذاكرة ليبني جداول الصفحات في هذا الجزء البعيد من المساحة، لأن جداول الصفحات نفسها تبنى عند الحاجة فقط. والدرس العملي هنا أن رقم الذاكرة الافتراضية Virtual Size الذي تعرضه بعض الأدوات لعملية ما قد يكون بالـ TB دون أن يعني أي شيء، فالمتصفحات وبيئات JavaScript وJava تحجز مساحات ضخمة عمداً لأسباب أمنية أو لتبسيط إدارة الكومة، والرقم الذي يعنيك هو Private وWorking Set.
ماذا يحدث إذا لمست ذاكرة غير مثبتة؟
الآن نخالف القاعدة عمداً لنرى الخطأ الذي سوف تقابله في برامجك. الوضع av-reserved يكتب في مدى محجوز غير مثبت، والوضع av-readonly يكتب في صفحة مثبتة بحماية القراءة فقط PAGE_READONLY:
> mem.exe av-reserved
reserved (not committed) region at 0000024B10CE0000, writing...
[exit code -1073741819 = 0xC0000005]
> mem.exe av-readonly
committed PAGE_READONLY page at 00000248F08E0000, reading: 0, now writing...
[exit code -1073741819 = 0xC0000005]في الحالتين انتهى البرنامج بالرمز 0xC0000005، وهو STATUS_ACCESS_VIOLATION، ولم يطبع السطر الأخير «never printed». والقراءة من صفحة القراءة فقط نجحت وأعادت صفراً، لأن كل صفحة مثبتة جديدة تبدأ مصفرة. وما يحدث داخل النظام في الحالتين يبدأ بالطريقة نفسها: المعالج لا يجد ترجمة صالحة للعنوان أو يجد ترجمة لا تسمح بالكتابة، فيرفع خطأ صفحة، ومعالج خطأ الصفحة في مدير الذاكرة يبحث في شجرة VAD، فإذا وجد أن العنوان محجوز فقط، أو أن الحماية لا تسمح بالكتابة، حول خطأ الصفحة إلى استثناء Exception يصل إلى البرنامج. والفرق بين الخطأ الطبيعي والقاتل إذن ليس في المعالج، وإنما في جواب الشجرة. ولذلك عندما ترى في سجل الأحداث أن برنامجاً انتهى بالرمز 0xC0000005، فالمعنى أنه وصل إلى عنوان لم يثبته أو لا يملك حق الكتابة فيه، وغالباً مؤشر Pointer تالف أو ذاكرة حررت ثم استعملت، وقد شرحنا هذا النوع من الأخطاء في مقال الذاكرة للمبرمجين.
خطأ الصفحة Page Fault: الصفحة تولد عند أول لمسة
رأينا أن أول كتابة في كل صفحة كلفت خطأ صفحة، ولكن ماذا عن القراءة؟ في Linux، كما في مقال الذاكرة الافتراضية، القراءة الأولى من ذاكرة جديدة لا تعطي العملية صفحة خاصة بها، وإنما تربطها بصفحة أصفار مشتركة، ولا تنشأ الصفحة الخاصة إلا عند الكتابة. فهل يفعل Windows الشيء نفسه؟ الوضع faults يجيب: يثبت 512 MB، ثم يقرأ بايتاً من كل صفحة، ثم يكتب، ثم يكتب مرة أخرى، ثم يملأ كل الذاكرة بالدالة memset:
> mem.exe faults
after commit 512 MB private 513.8 MB | working set 4.3 MB | page faults 1153 (+3) | system commit 65.52 / 111.87 GB
pass 1: READ one byte per page: 80.0 ms
after read pass private 513.8 MB | working set 516.4 MB | page faults 132503 (+131350) | system commit 65.52 / 111.87 GB
QueryWorkingSetEx page 0 after read Valid=1 Shared=0 ShareCount=0 Protection=0x4
pass 2: WRITE one byte per page: 1.4 ms
after write pass private 513.8 MB | working set 516.4 MB | page faults 132504 (+1) | system commit 65.52 / 111.87 GB
QueryWorkingSetEx page 0 after write Valid=1 Shared=0 ShareCount=0 Protection=0x4
pass 3: WRITE again: 1.5 ms
after second write pass private 513.8 MB | working set 516.4 MB | page faults 132504 (+0) | system commit 65.52 / 111.87 GB
memset of all 512 MB: 30.7 ms
after memset private 513.8 MB | working set 516.4 MB | page faults 132504 (+0) | system commit 65.56 / 111.87 GB
[exit code 0 = 0x00000000]وفي المخرج أعلاه لاحظ التالي:
- القراءة الأولى وحدها كلفت 131,350 خطأ صفحة، وأدخلت 512 MB كاملة إلى Working Set. عدد صفحات 512 MB هو 131,072، والباقي، حوالي 280، صفحات جداول الصفحات وصفحات البرنامج نفسه. أي أن Windows أعطى العملية صفحة حقيقية مصفرة عند القراءة الأولى، ولم يستعمل صفحة أصفار مشتركة كما يفعل Linux. وتسمي Microsoft هذا النوع خطأ صفحة يطلب صفحة مصفرة Demand-Zero Fault.
- الكتابة بعد القراءة لم تكلف أي خطأ، والتجربة تؤكد ذلك من زاويتين: العداد زاد بواحد فقط، والدالة QueryWorkingSetEx تقول إن الصفحة الأولى
Valid=1بعد القراءة وبعد الكتابة، أي أنها في Working Set وصالحة للمعالج. - الزمن: المرور الأول، مع أخطاء الصفحة، استغرق 80 ms، والمرور الثاني 1.4 ms. وإذا قسمت 80 ms على 131 ألف خطأ فستجد أن خطأ الصفحة الواحد كلف حوالي 0.6 ميكروثانية على هذا الجهاز، وهو رقم صغير لكل صفحة، ولكنه يتراكم: برنامج يحجز ويحرر مخازن كبيرة في كل طلب يدفع هذا الثمن في كل مرة.
memsetلكل 512 MB استغرقت 30.7 ms دون أي خطأ صفحة، وهي تكتب كل بايت لا بايتاً من كل صفحة، أي أن نسخ نصف جيجابايت أرخص من أخطاء الصفحة التي سبقته.
Pages Input/sec الذي سوف نراه في قسم القوائم.مجموعة العمل Working Set ومن يقلمها
مجموعة العمل، كما تعرفها Microsoft في صفحة Working Set، هي الصفحات من مساحة العملية الموجودة الآن في RAM، والتي تستطيع العملية أن تصل إليها دون خطأ صفحة. ولكل عملية حد أدنى وحد أعلى لمجموعة العمل، ولكن الحدين في Windows الحديث ليسا قيداً صارماً إلا إذا طلب البرنامج ذلك، وإنما إشارة لمدير مجموعات العمل: عندما تبدأ الذاكرة الحرة في الجهاز بالنقصان، يأخذ هذا المدير صفحات من العمليات التي تجاوزت حدها الأدنى، ويبدأ بالصفحات التي لم تستعمل منذ مدة، وهذه العملية اسمها التقليم Trimming.
والعملية تستطيع أن تقلم نفسها بنفسها، وهذا ما يفعله الوضع trim: يكتب 512 MB، ثم يستدعي EmptyWorkingSet، ثم يقرأ الذاكرة نفسها مرة أخرى:
static void trim(void) {
SIZE_T n = 512ull * 1024 * 1024;
char *p = VirtualAlloc(NULL, n, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
double t = touch(p, n, 1); out(L"first write of 512 MB (demand-zero faults): %7.1f ms\n", t); stats(L"after first write");
wsinfo(L"page 0 before trim", p);
BOOL ok = EmptyWorkingSet(GetCurrentProcess()); out(L"EmptyWorkingSet -> %d\n", ok); stats(L"after EmptyWorkingSet");
wsinfo(L"page 0 after trim", p);
Sleep(200);
t = touch(p, n, 0); out(L"read the 512 MB back (pages come back from RAM lists): %7.1f ms\n", t); stats(L"after reading back");والمخرج سوف يكون كما يلي:
> mem.exe trim
first write of 512 MB (demand-zero faults): 69.7 ms
after first write private 513.8 MB | working set 516.4 MB | page faults 132498 (+131350) | system commit 65.52 / 111.87 GB
QueryWorkingSetEx page 0 before trim Valid=1 Shared=0 ShareCount=0 Protection=0x4
EmptyWorkingSet -> 1
after EmptyWorkingSet private 513.8 MB | working set 0.2 MB | page faults 132550 (+52) | system commit 65.52 / 111.87 GB
QueryWorkingSetEx page 0 after trim Valid=0 Shared=0 ShareCount=0 Protection=0x0
read the 512 MB back (pages come back from RAM lists): 70.6 ms
after reading back private 513.8 MB | working set 512.3 MB | page faults 263913 (+131363) | system commit 65.50 / 111.87 GB
QueryWorkingSetEx page 0 after read back Valid=1 Shared=0 ShareCount=0 Protection=0x4
working set min/max (soft limits): 0.2 / 1.3 MB
SetProcessWorkingSetSize(-1, -1) -> 1
after SetProcessWorkingSetSize(-1,-1) private 513.8 MB | working set 0.3 MB | page faults 264014 (+101) | system commit 65.51 / 111.87 GB
[exit code 0 = 0x00000000]وفي المخرج أعلاه لاحظ التالي:
- بعد
EmptyWorkingSetنزل Working Set من 516.4 MB إلى 0.2 MB، بينما بقي Private عند 513.8 MB تماماً. فالعملية لم تفقد شيئاً من بياناتها، وإنما خرجت صفحاتها من مجموعة عملها فقط، والصفحة الأولى أصبحتValid=0. - قراءة 512 MB مرة أخرى كلفت 131,363 خطأ صفحة، واستغرقت 70.6 ms، أي قريباً جداً من زمن أول كتابة (69.7 ms). فأين كانت الصفحات؟ لم تكن على القرص، وإلا لاستغرقت القراءة ثواني، وإنما في قائمة من قوائم الذاكرة في RAM، فأعادها مدير الذاكرة إلى مجموعة العمل بتعديل جدول الصفحات فقط. وهذا النوع يسمى خطأ صفحة خفيف Soft Fault، ويسميه عداد الأداء Transition Fault، أما الخطأ الذي يقرأ من القرص فيسمى خطأ صفحة ثقيل Hard Fault.
- الحدان الأدنى والأعلى لمجموعة العمل كانا 0.2 و1.3 MB، والعملية تجاوزت الحد الأعلى بأكثر من 500 MB دون أي مشكلة، وهذا يؤكد أن الحد إشارة لا قيد. والقيد الصارم يحتاج الدالة
SetProcessWorkingSetSizeExمع علم خاص. SetProcessWorkingSetSize(-1, -1)هي الطريقة القديمة لطلب التقليم نفسه، ونتيجتها كانت مطابقة: 0.3 MB.
EmptyWorkingSet عليها جميعاً، فيظهر رقم الذاكرة المستخدمة في مدير المهام وقد انخفض. وما حدث في الحقيقة أن صفحات كل البرامج خرجت إلى القوائم، فتدفع كل البرامج خطأ صفحة عند عودتها إلى بياناتها، والصفحات المعدلة منها قد تكتب إلى ملف الصفحات دون حاجة. والنتيجة جهاز أبطأ برقم أجمل، فلا تقم بتثبيت هذه البرامج على سيرفر، ولا تضع EmptyWorkingSet في كود خدمة حتى «تبدو» أخف.القوائم في RAM: أين تذهب الصفحة؟
عندما تخرج صفحة من مجموعة عمل عملية، لا يمسح مدير الذاكرة محتواها فوراً، وإنما ينقلها إلى قائمة حسب حالتها، ويسجل ذلك في قاعدة PFN. والقوائم الرئيسية أربع:
- القائمة المعدلة Modified: صفحات كتبت فيها العملية ولم تحفظ نسخة منها على القرص بعد. ولا يمكن إعطاء هذه الصفحة لعملية أخرى قبل أن يكتبها الكاتب Modified Page Writer إلى ملف الصفحات، أو إلى ملفها الأصلي إن كانت من ملف معروض.
- قائمة الانتظار Standby: صفحات نظيفة، لها نسخة صحيحة على القرص، وما زال محتواها في RAM. وإذا احتاجتها العملية أعيدت بخطأ خفيف، وإذا احتاج النظام صفحة لغيرها أخذها منها فوراً دون أي كتابة. ولهذه القائمة ثماني أولويات منذ Windows Vista، فصفحات ملفات تفتحها كثيراً تبقى أطول من صفحات ملف قرأته مرة واحدة، وهذه القائمة هي ذاكرة التخزين المؤقت Cache الحقيقية في Windows، وهي الجزء الأكبر من الرقم الذي يعرضه مدير المهام باسم Cached.
- قائمة الصفحات الحرة Free: صفحات لا يحتاجها أحد ومحتواها قديم.
- قائمة الصفحات المصفرة Zero: صفحات حرة ملأها خيط Zero Page Thread بالأصفار، وهي التي تعطى عند خطأ يطلب صفحة مصفرة مثل الذي رأيناه في تجربة الأخطاء.
ومنذ Windows 10 أضيفت طبقة أخرى: بدل أن يكتب النظام الصفحات المعدلة إلى ملف الصفحات مباشرة، يستطيع أن يضغطها ويحفظها في مخزن داخل عملية خاصة اسمها Memory Compression، فإذا عادت إليها العملية فك ضغطها في RAM، وهذا أرخص كثيراً من القراءة من القرص. والسكربت 05-system.ps1 يقرأ هذه القوائم من عدادات الأداء Performance Counters، وهي متاحة للمستخدم العادي:
available mbytes 31,695
free & zero page list bytes 6,922 MB
standby cache core bytes 117 MB
standby cache normal priority bytes 12,735 MB
standby cache reserve bytes 11,921 MB
modified page list bytes 438 MB
committed bytes 65,708 MB
commit limit 114,556 MB
pool paged bytes 3,897 MB
pool nonpaged bytes 1,947 MB
page faults/sec 226,302
demand zero faults/sec 38,530
transition faults/sec 20,350
cache faults/sec 162,375
pages input/sec 1,378
page reads/sec 191
% usage 5
Memory Compression process: PID 3488, working set 3,221 MB
وفي المخرج أعلاه لاحظ التالي:
- الذاكرة المتاحة
Available MBytesكانت 31,695 MB، وإذا جمعت الصفحات الحرة والمصفرة (6,922) مع القوائم الثلاث لـ Standby (117 و12,735 و11,921) فستحصل على 31,695 تقريباً. أي أن «المتاحة» في Windows تعني: صفحات يستطيع النظام أن يعطيها لأي طلب جديد دون أن يكتب شيئاً إلى القرص، وأكثر من ثلاثة أرباعها هنا ليست فارغة، وإنما محتوى ملفات وبيانات قد يحتاجها أحد. ولهذا يبدو أن Windows «يستهلك» الذاكرة كلها بعد ساعات من التشغيل، وهو في الحقيقة يستعمل الذاكرة غير المطلوبة كذاكرة مؤقتة بدل أن يتركها فارغة دون فائدة. - القائمة المعدلة 438 MB، وهي ما ينتظر الكتابة إلى ملف الصفحات أو إلى ملفاته.
- عداد الأخطاء الكلي للجهاز 226,302 خطأ في الثانية، منها 38,530 خطأ يطلب صفحة مصفرة و20,350 خطأ انتقالي Transition و162,375 خطأ في ذاكرة الملفات Cache Faults، بينما الصفحات المقروءة من القرص
Pages Input/secكانت 1,378 فقط في عينة الخمس ثوان. أي أن الغالبية الساحقة من أخطاء الصفحة لا تلمس القرص، والعداد الذي يخبرك أن الجهاز يعاني من نقص الذاكرة هوPages Input/secوPage Reads/secعندما يرتفعان ويستمران، لاPage Faults/sec. - عملية Memory Compression مجموعة عملها 3,221 MB، وهذا هو حجم الصفحات المضغوطة المحفوظة في RAM بدل القرص. وهذه العملية لا تظهر في تبويب العمليات في مدير المهام، ولكنك تراها في Process Explorer وفي
Get-Process. - ملف الصفحات مستخدم بنسبة 5%، أي حوالي 2.4 GB من 48 GB.
ملف الصفحات Pagefile وحد التثبيت Commit Limit
ملف الصفحات pagefile.sys له وظيفتان تذكرهما Microsoft في صفحة Introduction to the page file: أن يكون مكاناً للصفحات الخاصة المعدلة التي تخرج من RAM، وأن يرفع حد التثبيت للجهاز، لأن هذا الحد هو مجموع RAM وكل ملفات الصفحات. ووظيفة ثالثة يغفل عنها كثيرون: أن يحمل ملف التفريغ Crash Dump عندما يتوقف الجهاز بشاشة زرقاء. وهذا يعني أن قرار حجم ملف الصفحات لا يتعلق بالبطء، وإنما بسؤال واحد: ما أعلى تثبيت يحتاجه الجهاز في أسوأ لحظة؟
ولنعد إلى الوعد: عندما يثبت برنامج ذاكرة، يحسب النظام الوعد على الحد فوراً، فإذا وصل مجموع الوعود إلى الحد رفض النظام أي تثبيت جديد، حتى لو كانت RAM فيها صفحات متاحة كثيرة، لأنه لا يستطيع أن يضمن مكاناً لكل الصفحات لو لمستها البرامج كلها في وقت واحد. وهذا هو الفرق الأهم بين Windows وLinux في هذا الجانب: Linux يسمح افتراضياً بالحجز الزائد Overcommit ثم يقتل عملية عندما تنفد الذاكرة فعلاً، كما رأينا في مقال الذاكرة الافتراضية، وWindows يرفض الطلب من البداية ويعيد للبرنامج خطأ يستطيع أن يتعامل معه. والوضع biglimit يجرب الحد بطلبين:
> mem.exe biglimit
start commit in use 65.0 GB | commit limit 111.9 GB
commit 1024.0 GB -> NULL, error 1455, 3.47 ms
commit 50.9 GB -> OK, error 0, 0.87 ms
while holding it commit in use 116.0 GB | commit limit 116.0 GB
this process private 52182.4 MB | working set 4.5 MB | page faults 1191 (+42) | system commit 115.97 / 115.98 GB
after release commit in use 65.0 GB | commit limit 117.0 GB
reserve (no commit) 1024.0 GB -> OK
[exit code 0 = 0x00000000]وفي المخرج أعلاه لاحظ التالي:
- طلب تثبيت 1024 GB فشل خلال 3.47 ms بالخطأ 1455، وهو
ERROR_COMMITMENT_LIMIT، ونصه في قائمة رموز أخطاء النظام «The paging file is too small for this operation to complete». وهذا هو الرقم الذي سوف تراه عندما يفشل برنامج في طلب ذاكرة على Windows، وهو غير «نفاد RAM». - حجز 1024 GB دون تثبيت نجح في السطر الأخير، فالحد لا يعرف شيئاً عن الحجز.
- الطلب الثاني كان 50.9 GB، أي المتبقي من الحد مع 4 GB زيادة، ونجح. وأثناء الاحتفاظ به أصبح التثبيت 116.0 GB والحد 116.0 GB أيضاً، أي أن الحد نفسه ارتفع من 111.9 إلى 116.0 GB. والسبب أن ملف الصفحات هنا يديره النظام، وتقول Microsoft في الصفحة نفسها إن ملف الصفحات الذي يديره النظام يكبر تلقائياً عندما يصل التثبيت إلى 90% من الحد، حتى ثلاثة أضعاف RAM أو 4 GB أيهما أكبر، بشرط ألا يتجاوز ثمن حجم القرص وأن توجد مساحة كافية. والقرص
F:عليه مساحة كبيرة، فكبر الملف بدل أن يرفض الطلب. - بعد التحرير بقي الحد 117.0 GB للحظة، ثم عاد بعد قليل إلى 114,556 MB، أي 111.9 GB، وعاد حجم الملف إلى 49,152 MB، كما يظهر في مخرج عدادات الأداء وفي فحص
Win32_PageFileUsageبعد التجربة.

biglimit على سيرفر يخدم مستخدمين أو جهاز يعمل عليه شيء مهم، وشغله على جهاز اختبار فقط.هل تعطل ملف الصفحات إذا كان عندك ذاكرة كثيرة؟
هذه نصيحة تتكرر في المنتديات، والمنطق خلفها أن الجهاز لن يحتاج القرص ما دامت RAM كبيرة. والمشكلة أن هذا المنطق ينظر إلى Working Set لا إلى التثبيت: إذا عطلت ملف الصفحات أصبح الحد هو RAM وحدها، وكل وعد يقطعه برنامج يحجز من RAM مكاناً حتى لو لم يلمسه أبداً. وبرامج كثيرة تثبت أكثر مما تستعمل، مثل بعض المتصفحات وبيئات Java التي تثبت الكومة كاملة عند البدء، وبالتالي تصل إلى الخطأ 1455 وما زالت الذاكرة الفعلية نصف فارغة. وتضيف Microsoft في صفحة تحديد الحجم المناسب لملف الصفحات أن الطريقة الصحيحة للحجم هي قياس أعلى تثبيت يصل إليه الجهاز في ذروة عمله، عبر العدادين Committed Bytes وCommit Limit، ثم ترك هامش فوقه، مع مراعاة نوع ملف التفريغ الذي تريده عند الأعطال. والحل الأنسب لأغلب الأجهزة أن تترك النظام يدير الحجم كما في جهاز المختبر، وأن تضع الملف على قرص سريع فيه مساحة إذا كان قرص النظام صغيراً.
الأقسام Sections: ذاكرة واحدة في عمليتين
كل ما رأيناه حتى الآن ذاكرة خاصة Private بعملية واحدة. أما الذاكرة المشتركة فتمر في Windows بكائن في النواة اسمه القسم Section Object، وتنشئه من وضع المستخدم بالدالة CreateFileMappingW، ثم تفتح منه كل عملية عرضاً View بالدالة MapViewOfFile. والقسم نوعان كما تشرح صفحة File Mapping: قسم خلفه ملف على القرص، وقسم خلفه ملف الصفحات، وهو ما تحصل عليه عندما تمرر INVALID_HANDLE_VALUE بدل مقبض ملف، وهو الطريقة المعتادة لذاكرة مشتركة بين عمليتين كما في مثال Microsoft Creating Named Shared Memory. والقسم كائن له اسم ومقبض مثل الأحداث Events والأقفال Mutexes، وتفاصيل الأسماء ومن يحق له فتحها هي موضوع مقال المقابض والكائنات في هذه المرحلة، أما هنا فننظر إلى جانب الذاكرة فقط.
والوضع shared ينشئ قسماً من 64 MB باسم Local\arabroot-wn3-map، ويكتب فيه نصاً عربياً، ثم يشغل نسخة ثانية من البرنامج تفتح القسم بالاسم وتقرؤه وتكتب رداً، ثم تفتح عرضاً آخر من القسم نفسه بالنسخ عند الكتابة FILE_MAP_COPY:
static void shared(void) {
stats(L"parent start");
HANDLE m = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, MAPSIZE, MAPNAME);
out(L"parent: CreateFileMappingW(pagefile-backed, 64 MB, %ls) -> %p, error %lu\n", MAPNAME, m, GetLastError());
stats(L"parent after CreateFileMappingW");
char *v = MapViewOfFile(m, FILE_MAP_ALL_ACCESS, 0, 0, 0);
stats(L"parent after MapViewOfFile");والمخرج سوف يكون كما يلي:
> mem.exe shared
parent start private 0.8 MB | working set 4.3 MB | page faults 1150 (+2) | system commit 65.02 / 111.87 GB
parent: CreateFileMappingW(pagefile-backed, 64 MB, Local\arabroot-wn3-map) -> 00000000000000CC, error 0
parent after CreateFileMappingW private 0.8 MB | working set 4.4 MB | page faults 1176 (+26) | system commit 65.08 / 111.87 GB
parent after MapViewOfFile private 0.9 MB | working set 4.4 MB | page faults 1177 (+1) | system commit 65.08 / 111.87 GB
parent after writing 64 MB private 0.9 MB | working set 68.4 MB | page faults 17593 (+16416) | system commit 65.08 / 111.87 GB
QueryWorkingSetEx parent page 0 Valid=1 Shared=1 ShareCount=7 Protection=0x4
child after MapViewOfFile private 0.9 MB | working set 4.3 MB | page faults 1153 (+3) | system commit 65.08 / 111.87 GB
child: view at 00000265EAAC0000, text from parent: مرحباً من العملية الأولى
QueryWorkingSetEx child page 0 Valid=1 Shared=1 ShareCount=7 Protection=0x4
child: read all 64 MB of the view: 34.2 ms
child after reading 64 MB private 0.9 MB | working set 68.4 MB | page faults 17593 (+16440) | system commit 65.09 / 111.87 GB
QueryWorkingSetEx child page 0 now Valid=1 Shared=1 ShareCount=7 Protection=0x4
child after a FILE_MAP_COPY view private 65.0 MB | working set 68.4 MB | page faults 17593 (+0) | system commit 65.16 / 111.87 GB
child: wrote 'X' and 'Y' into two pages of the copy-on-write view
child after writing 2 COW pages private 65.0 MB | working set 68.4 MB | page faults 17595 (+2) | system commit 65.16 / 111.87 GB
QueryWorkingSetEx child COW page 0 Valid=1 Shared=0 ShareCount=0 Protection=0x4
parent: reply written by the child at offset 4096: رد من العملية الثانية
parent: first bytes of page 0 and page 2: '-' '-' (the child's COW writes stayed private)
parent: after the last handle closed, OpenFileMappingW -> 0000000000000000, error 2
[exit code 0 = 0x00000000]وفي المخرج أعلاه لاحظ التالي:
- إنشاء القسم وفتح العرض لم يغيرا Private ولا Working Set تقريباً، ولكن تثبيت الجهاز زاد من 65.02 إلى 65.08 GB، أي 64 MB تقريباً. فالقسم الذي خلفه ملف الصفحات يحسب على حد الجهاز مرة واحدة عند إنشائه، ولكنه لا يحسب في Private Bytes لأي عملية، لأنه ليس خاصاً بأحد. وهذا سبب شائع لاختلاف مجموع Private Bytes للعمليات عن تثبيت الجهاز.
- كتابة 64 MB في الأب كلفت 16,416 خطأ صفحة ورفعت Working Set إلى 68.4 MB، وبقي Private عند 0.9 MB. والدالة
QueryWorkingSetExتقول عن الصفحة الأولىShared=1. - الابن فتح القسم بالاسم ووجد النص «مرحباً من العملية الأولى» كما كتبه الأب، ثم قرأ 64 MB في 34.2 ms، فحدث له 16,440 خطأ صفحة وزاد Working Set لديه إلى 68.4 MB، ولم يتغير تثبيت الجهاز ولا Private. وهذه أخطاء خفيفة: الصفحات موجودة في RAM لأن الأب كتبها، والنظام يربطها فقط بجدول صفحات العملية الثانية. أي أن الـ 64 MB نفسها تظهر في Working Set للعمليتين، ولكنها في RAM مرة واحدة، ولذلك لا تجمع Working Set العمليات لتعرف كم من RAM مستهلك.
- الرد وصل: الأب قرأ في الإزاحة 4096 النص «رد من العملية الثانية» الذي كتبه الابن.
- بمجرد أن فتح الابن عرض
FILE_MAP_COPYارتفع Private لديه من 0.9 إلى 65.0 MB قبل أن يكتب أي بايت. والسبب أن النسخ عند الكتابة وعد: كل صفحة في هذا العرض قد تصبح نسخة خاصة بالعملية عند أول كتابة، فيثبت النظام مكانها مسبقاً. وعندما كتب الابن في صفحتين حدث خطآن فقط، وأصبحت الصفحة الأولى في هذا العرضShared=0، ولم ير الأب الحرفين X وY، فالسطر قبل الأخير يطبع «-» للصفحتين. - بعد أن أغلق الأب آخر مقبض وآخر عرض فشل
OpenFileMappingWبالخطأ 2، أي أن القسم لم يعد موجوداً. فالقسم الذي خلفه ملف الصفحات يعيش ما دام له مقبض أو عرض مفتوح، ثم يختفي مع بياناته، ولا يبقى منه شيء على القرص.

ملف على القرص كأنه ذاكرة
النوع الثاني من الأقسام خلفه ملف حقيقي، وهو الطريقة التي يحمل بها Windows كل ملف تنفيذي ومكتبة DLL: يعرض الملف في مساحة العملية ويترك أخطاء الصفحة تقرأ منه ما تحتاجه فقط، كما رأينا في مقال المكتبات المشتركة DLL. والوضع filemap يعرض ملفاً من 256 MB للقراءة فقط ويقرأ بايتاً من كل صفحة:
> mem.exe filemap "C:\lab\data-256mb.bin"
start private 0.8 MB | working set 4.3 MB | page faults 1149 (+2) | system commit 64.94 / 111.87 GB
mapped 256 MB file read-only at 0000023954A20000
after MapViewOfFile private 1.3 MB | working set 4.5 MB | page faults 1185 (+36) | system commit 64.94 / 111.87 GB
read one byte per page: 133.2 ms (sum 32640)
after reading the file private 1.3 MB | working set 260.5 MB | page faults 66850 (+65665) | system commit 64.95 / 111.87 GB
after unmap private 0.8 MB | working set 4.5 MB | page faults 66852 (+2) | system commit 64.95 / 111.87 GB
[exit code 0 = 0x00000000]القراءة رفعت Working Set إلى 260.5 MB بعد 65,665 خطأ صفحة، بينما بقي Private عند 1.3 MB وتثبيت الجهاز لم يتحرك. فصفحات ملف معروض للقراءة لا تحتاج وعداً من حد التثبيت، لأن لها مكاناً على القرص في الملف نفسه، وإذا احتاج النظام RAM يرميها ببساطة ثم يقرؤها من الملف عند الحاجة. وكانت أغلب هذه الأخطاء خفيفة أيضاً، لأن السكربت كتب الملف قبل لحظات فبقيت صفحاته في ذاكرة الملفات، ولو كان الملف قديماً لم يقرأ منذ مدة لكانت القراءة من القرص واستغرقت وقتاً أطول بكثير من 133 ms.
حد الذاكرة داخل كائن Job
كائن Job هو الطريقة التي يجمع بها Windows عدة عمليات تحت حدود واحدة، وموضوعه الكامل، مع حدود المعالج وعدد العمليات، في مقال العمليات والخيوط وكائنات Job من هذه المرحلة. أما هنا فنجرب حداً واحداً يخص الذاكرة: ProcessMemoryLimit في البنية JOBOBJECT_EXTENDED_LIMIT_INFORMATION، وتقول الوثائق إنه حد «للذاكرة الافتراضية التي يمكن أن تثبتها العملية»، أي أنه حد على Private Bytes لا على Working Set. والوضع job ينشئ Job بحد 512 MB، ثم يشغل نسخة من البرنامج معلقة، ويضعها في الـ Job قبل أن تنفذ أي سطر، ثم يتركها تعمل:
static void job(void) {
HANDLE j = CreateJobObjectW(NULL, NULL);
JOBOBJECT_EXTENDED_LIMIT_INFORMATION li = { 0 };
li.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_PROCESS_MEMORY | JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
li.ProcessMemoryLimit = 512ull * 1024 * 1024;
out(L"parent: SetInformationJobObject(ProcessMemoryLimit = 512 MB) -> %d\n", SetInformationJobObject(j, JobObjectExtendedLimitInformation, &li, sizeof li));
wchar_t exe[MAX_PATH], cmd[MAX_PATH + 16]; GetModuleFileNameW(NULL, exe, MAX_PATH); swprintf(cmd, MAX_PATH + 16, L"\"%ls\" grow", exe);
STARTUPINFOW si = { sizeof si }; PROCESS_INFORMATION pi;
if (!CreateProcessW(NULL, cmd, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi)) { fail(L"CreateProcessW"); return; }
out(L"parent: AssignProcessToJobObject -> %d\n", AssignProcessToJobObject(j, pi.hProcess));والابن في الوضع grow يحجز 8 GB أولاً، ثم يثبت 64 MB في كل مرة حتى يفشل، ثم يجرب malloc بحجمين:
> mem.exe job
parent: SetInformationJobObject(ProcessMemoryLimit = 512 MB) -> 1
parent: AssignProcessToJobObject -> 1
child: reserve 8 GB inside the job -> OK
child after reserve private 0.8 MB | working set 4.3 MB | page faults 1159 (+8) | system commit 65.02 / 111.87 GB
child: commit #8 of 64 MB failed, error 1455, committed so far 448 MB
child at the limit private 449.7 MB | working set 4.4 MB | page faults 1177 (+18) | system commit 65.45 / 111.87 GB
child: malloc(100 MB) -> NULL
child: malloc(1 KB) -> pointer
parent: child exit code 0, job peak process memory 450 MB
[exit code 0 = 0x00000000]وفي المخرج أعلاه لاحظ التالي:
- حجز 8 GB داخل Job حده 512 MB نجح، فالحد يحسب التثبيت فقط، كما يقول تعريفه.
- سبع دفعات من 64 MB نجحت، أي 448 MB، والثامنة فشلت بالخطأ 1455 نفسه الذي رأيناه مع حد الجهاز، ولم تفشل عند 512 بالضبط لأن البرنامج نفسه، بكوده ومكتباته وكومته، كان قد ثبت حوالي 1 MB قبل البداية، فالدفعة الثامنة كانت ستتجاوز الحد. والبرنامج الذي يقرأ هذا الخطأ لا يستطيع أن يفرق بين «الجهاز امتلأ» و«الـ Job الذي أنا فيه امتلأ»، وهذا تفصيل يجب أن تعرفه عندما تشغل خدمة داخل Container على Windows، لأن حدود الذاكرة في Windows Containers مبنية على كائنات Job.
malloc(100 MB)أعادNULL، وmalloc(1 KB)نجح، لأن الكومة ما زال فيها مكان صغير مثبت. وهذا هو الشكل الذي سوف تراه في برنامجك: طلبات صغيرة تنجح وكبيرة تفشل، فإذا كان الكود لا يفحص قيمةmallocفسوف ينتهي بخطأ وصول للذاكرة لا برسالة واضحة.- النظام لم يقتل الابن، فقد خرج بالرمز 0 بعد أن طبع ما يريد، وقرأ الأب من الـ Job أن أعلى استهلاك للعملية كان 450 MB.

الصفحات الكبيرة Large Pages
المعالجات الحديثة تستطيع أن تترجم صفحة من 2 MB بمدخل واحد في جداول الصفحات وذاكرة الترجمات TLB بدل 512 مدخلاً، وهذا يسرع البرامج التي تقرأ مساحات كبيرة عشوائياً، مثل قواعد البيانات. وسطر large page minimum في مخرج الإعداد يقول إن الحجم على هذا الجهاز 2,097,152 بايت. ولكن صفحات Windows الكبيرة لها شرط تذكره صفحة Large-Page Support: لا يمكن نقلها إلى ملف الصفحات، أي أنها تبقى في RAM دائماً، ولذلك يحتاج البرنامج امتيازاً Privilege اسمه SeLockMemoryPrivilege لا يملكه المستخدم العادي ولا حتى المدير افتراضياً:
> mem.exe large
VirtualAlloc 2097152 bytes with MEM_LARGE_PAGES -> 0000000000000000, error 1314
AdjustTokenPrivileges(SeLockMemoryPrivilege) -> 1, GetLastError 1300
[exit code 0 = 0x00000000]الطلب فشل بالخطأ 1314، وهو ERROR_PRIVILEGE_NOT_HELD. ثم حاولنا تفعيل الامتياز بالدالة AdjustTokenPrivileges، فأعادت الدالة TRUE ولكن GetLastError قال 1300، أي ERROR_NOT_ALL_ASSIGNED: الدالة لا تفشل عندما تطلب امتيازاً لا يملكه رمز الأمان Token، وإنما تنجح وتترك الخطأ في GetLastError، وهذا فخ معروف سوف نعود إليه في مقال رموز الأمان. وعلى السيرفرات التي تحتاج الصفحات الكبيرة، مثل SQL Server، يعطي المدير هذا الامتياز لحساب الخدمة عبر سياسة Lock pages in memory، وهو قرار يجب أن يكون مقصوداً، لأن الذاكرة المقفلة لا يستطيع النظام أن يستعيدها مهما احتاج إليها.
VMMap: خريطة ذاكرة عمليتك
كل ما قرأناه بالدوال تعرضه أداة VMMap من Sysinternals في نافذة واحدة، وهي تعمل بصلاحيات المستخدم العادي على عملياته هو، وقد شرحنا في مقال أدوات Sysinternals كيف تنزلها وتتحقق من توقيعها قبل التشغيل. والسكربت 06-vmmap.ps1 يشغل البرنامج في الوضع hold، الذي يحجز 8 GB ويثبت منها 1 GB ويلمس 256 MB ويفتح قسماً مشتركاً من 64 MB ثم ينتظر، ثم يشغل VMMap على رقم هذه العملية ويطلب منها حفظ تقرير بصيغة CSV دون واجهة:
vmmap64.exe -accepteula -p <PID> vmmap-mem.csvوالجزء الأول من التقرير، وهو ملخص الأنواع بالكيلوبايت، كان كما يلي:
> mem.exe hold 90
hold: pid 45000, reserved 8 GB at 000001F475C00000 (1 GB committed, 256 MB touched), 64 MB shared view at 000001F400000000
VMMap exit code 0, report rows 227
"Process:","mem.exe"
"PID:","45000"
"Type","Size","Committed","Private","Total WS","Private WS","Shareable WS","Shared WS","Locked WS","Blocks","Largest",
"Total","12,707,136","1,128,100","1,049,152","332,208","262,632","69,576","69,576","","120",""
"Free","137,426,246,272","","","","","","","","15","135,282,119,360"
"Heap","1,552","224","160","164","160","4","4","","9","1,024"
"Image","12,188","12,060","296","3,944","256","3,688","3,688","","72","4,120"
"Managed Heap","","","","","","","","","",""
"Mapped File","1,140","1,140","","80","","80","80","","7","844"
"Page Table","","","","","","","","","",""
"Private Data","12,617,876","1,048,624","1,048,624","262,188","262,180","8","8","","11","8,388,608"
"Shareable","66,988","65,980","","65,796","","65,796","65,796","","12","65,536"
"Stack","6,144","72","72","36","36","","","","9","2,048"
"Unusable","1,248","","","","","","","","","60"والصورة التالية للنافذة نفسها على العملية نفسها من تشغيل سابق للسكربت نفسه، والأرقام فيها مطابقة تقريباً:

وفي التقرير والصورة لاحظ التالي:
- Private Data: الحجم 12,617,876 K، منها 8 GB حجزناها، و1,048,624 K مثبتة، أي 1 GB، و262,188 K في Working Set، أي الـ 256 MB التي لمسناها. وعمود Largest يقول إن أكبر كتلة 8,388,608 K، أي حجزنا الكبير.
- Shareable: 65,980 K مثبتة و65,796 K في Working Set، وهي في أغلبها القسم المشترك من 64 MB. ولاحظ أن عمود Private فارغ لهذا النوع، كما رأينا في التجربة.
- Image: 12,060 K مثبتة، وهي ملف
mem.exeوالمكتبات مثلntdll.dllوKernelBase.dll، ومنها 3,688 K مشتركة مع عمليات أخرى تستعمل المكتبات نفسها، و256 K فقط خاصة. - Stack: الحجم 6,144 K والمثبت 72 K فقط، وهذا مثال حي على الحجز والتثبيت: لكل خيط من الخيوط الثلاثة 2 MB محجوزة، والمثبت منها صفحات قليلة.
- Unusable: 1,248 K من العناوين الضائعة بين نهاية الحجوزات الصغيرة وحد الـ 64 KB التالي، وهو الأثر الذي رأيناه مع حجز الصفحة الواحدة.
- Free: حوالي 137 مليار كيلوبايت، أي 128 TB تقريباً، وهي بقية مساحة العناوين التي لم يلمسها البرنامج.
والجزء السفلي من النافذة يعرض كل مدى على حدة بعنوانه ونوعه وحمايته، ومنه تعرف مثلاً أين يقع الـ Stack لكل خيط، وأين تبدأ كل كومة، وما الملفات المعروضة:

ولاحظ في القائمة السفلية سطر Thread Environment Block، وأسطر Thread Stack مع رقم كل خيط، وأسطر Heap مع نوع كل كومة مثل LOW FRAGMENTATION، وأسطر Mapped File لملفات اللغة مثل locale.nls التي يعرضها Windows في كل عملية. وعندما تحقق في تسرب ذاكرة حقيقي، فالطريقة العملية أن تأخذ لقطتين من VMMap للخدمة نفسها بفارق ساعة، ثم تقارن النوع الذي يكبر: إذا كان Heap فالتسرب في malloc أو new، وإذا كان Private Data فالتسرب في VirtualAlloc مباشرة أو في كومة مدارة Managed Heap، وإذا كان Shareable أو Mapped File فالمشكلة في أقسام تفتح ولا تغلق.
مشكلة قابلتنا أثناء كتابة المختبر
المشكلة الأولى كانت في تجربة حد التثبيت. النسخة الأولى من الوضع biglimit طلبت تثبيت مرة ونصف حد الجهاز، أي حوالي 167.8 GB، وكنا نتوقع الخطأ 1455 بكل تأكيد، فنجح الطلب في 193 ms. والسبب هو ما شرحناه في قسم ملف الصفحات: الحد الحالي ليس الحد النهائي عندما يدير النظام ملف الصفحات، فالملف يستطيع أن يكبر حتى ثلاثة أضعاف RAM، أي حوالي 192 GB على هذا الجهاز، والحد النهائي إذن قرابة 256 GB. وهذا التشغيل هو الذي ترك الرقم 238,339 MB في خانة أعلى تثبيت في مخرج الإعداد. وبعد ذلك غيرنا التجربة إلى طلب مستحيل (1024 GB) يوضح الخطأ، وطلب قريب من الحد يوضح النمو، وأضفنا التحذير الذي قرأته أعلاه. والدرس للقارئ: لا تفترض أن الرقم Commit Limit في مدير المهام هو السقف الحقيقي، وإذا كان ملف الصفحات بإدارة النظام فالسقف يتحرك.
والمشكلة الثانية كانت في الحقل ShareCount من نتيجة QueryWorkingSetEx. أردنا أن نرى العدد يرتفع من 1 إلى 2 عندما تفتح العملية الثانية القسم، فوجدنا القيمة 7 في الأب قبل أن يبدأ الابن أصلاً، وبقيت 7 بعده. ووثائق البنية PSAPI_WORKING_SET_EX_BLOCK تقول إن هذا الحقل عدد العمليات التي تشارك الصفحة وإن أكبر قيمة له 7، فهو ثلاث بتات فقط، والقيمة لصفحات الأقسام لم تكن مفيدة في تجربتنا. لذلك اعتمدنا في المقال على الحقل Shared وعلى أرقام Working Set وPrivate، ولا تعتمد أنت على ShareCount لتعد العمليات التي تفتح قسماً، فالطريقة الصحيحة لذلك أن تسأل عن المقابض المفتوحة على الكائن.
أخطاء شائعة Common Mistakes
- جمع Working Set للعمليات لمعرفة استهلاك RAM: الصفحات المشتركة، مثل المكتبات والأقسام، تحسب في كل عملية تستعملها، وقد رأينا 64 MB تظهر في عمليتين. لاستهلاك الجهاز انظر إلى عدادات الجهاز، ولاستهلاك العملية الخاص انظر إلى Private Working Set.
- الحكم على تسرب الذاكرة من Working Set: هذا الرقم ينزل عندما يقلم النظام العملية ويرتفع عندما تعود، فقد يبدو مستقراً والتسرب مستمر. الرقم الذي يكشف التسرب هو Private Bytes على مدى ساعات.
- اعتبار «الذاكرة المتاحة» القليلة مشكلة: أغلب المتاح في Standby، أي محتوى مفيد، والذاكرة الفارغة في Windows ذاكرة ضائعة. المشكلة الحقيقية أن يقترب التثبيت من حده أو أن يستمر
Pages Input/secمرتفعاً. - تعطيل ملف الصفحات على جهاز فيه ذاكرة كثيرة: ينخفض حد التثبيت إلى RAM وحدها، فتفشل البرامج بالخطأ 1455 وRAM نصف فارغة، ويضيع ملف التفريغ عند الشاشة الزرقاء.
- تثبيت الذاكرة كلها مقدماً «احتياطاً»: كل وعد يحسب على حد الجهاز حتى لو لم يلمس، والطريقة الصحيحة أن تحجز المدى ثم تثبت عند الحاجة.
- حجز صفحات صغيرة كثيرة بالدالة
VirtualAlloc: كل حجز يأخذ 64 KB من العناوين ويترك الباقي ضائعاً، فاستعمل الكومة للحجوزات الصغيرة. - عدم فحص قيمة
mallocوVirtualAlloc: داخل Job أو Container محدود، الطلبات الكبيرة تفشل والصغيرة تنجح، والكود الذي لا يفحص ينتهي بخطأ0xC0000005بعيداً عن مكان المشكلة. - برامج تنظيف الذاكرة واستدعاء
EmptyWorkingSetفي الكود: الرقم ينخفض والجهاز يبطؤ، لأن كل صفحة تعود بخطأ صفحة. - قراءة عدد أخطاء الصفحة كمؤشر على القرص: في المختبر كانت مئات الآلاف من الأخطاء في الثانية وأقل من ألفي صفحة من القرص.
جدول قرار: ماذا تفعل عندما ترى…؟
| ما تراه | ماذا يعني غالباً | ماذا تفعل |
|---|---|---|
| Private Bytes لخدمة يرتفع ساعة بعد ساعة ولا ينزل | تسرب ذاكرة في الخدمة | خذ لقطتين من VMMap بفارق ساعة وقارن النوع الذي يكبر: Heap أو Private Data أو Shareable |
| Working Set ينخفض فجأة لكل العمليات | النظام يقلم لأن الذاكرة نقصت، أو أداة تنظيف تستدعي EmptyWorkingSet | راقب Pages Input/sec، وأزل أدوات التنظيف |
| الخطأ 1455 أو رسالة نقص الذاكرة الافتراضية وRAM فيها مساحة | التثبيت وصل إلى حده | قارن Committed Bytes وCommit Limit، وابحث عن العملية بأكبر Private، وكبر ملف الصفحات أو اتركه بإدارة النظام |
| الخطأ 1455 داخل Container أو Job فقط | حد الـ Job لا حد الجهاز | اقرأ حد الذاكرة في إعدادات الـ Container، وارفع الحد أو خفض الاستهلاك |
«الذاكرة المتاحة» قليلة وPages Input/sec منخفض | Standby ممتلئة بذاكرة مؤقتة مفيدة | لا شيء، فهذا الوضع الطبيعي |
Pages Input/sec مرتفع باستمرار مع بطء | أخطاء ثقيلة: الجهاز يحتاج ذاكرة أكثر من RAM | قلل العمليات أو زد RAM، وانظر إلى Working Set لأكبر العمليات |
| عملية برقم Virtual Size بالـ TB | حجز عناوين فقط | تجاهل الرقم وانظر إلى Private وWorking Set |
برنامج ينتهي بالرمز 0xC0000005 | وصول إلى عنوان غير مثبت أو حماية لا تسمح | ابحث عن مؤشر تالف أو ذاكرة حررت ثم استعملت، أو طلب ذاكرة فشل ولم يفحص |
تدريب عملي Practice
- شغل البرنامج في الوضع
hold 300، وافتح Process Explorer وأضف العمودين Private Bytes وWorking Set، ثم افتح مدير المهام وقارن ما يعرضه في عمود الذاكرة بالرقمين. أي رقم يعرض مدير المهام؟ - عدل الوضع
trimبحيث ينتظر 30 ثانية بين التقليم والقراءة، وشغل خلال الانتظار برنامجاً يستهلك ذاكرة كبيرة، ثم قارن زمن القراءة بزمن التجربة الأصلية. هل أصبحت بعض الأخطاء ثقيلة؟ - عدل الوضع
jobبحيث يستعملJOB_OBJECT_LIMIT_JOB_MEMORYبدل حد العملية، وشغل داخل الـ Job نسختين منgrow، ولاحظ كيف يتقاسمان الحد.
حذف المختبر Cleanup
السكربت الأخير 99-cleanup.ps1 يوقف أي نسخة متبقية من mem.exe تعمل من مجلد المختبر، ثم يحذف المجلد في %TEMP% بكل ما فيه، وطبع lab folder removed: True. والأقسام المشتركة لا تحتاج حذفاً لأنها تختفي مع آخر مقبض، وملف الصفحات عاد إلى حجمه الأصلي بعد تجربة الحد. ولم يغير المختبر شيئاً في السجل غير المفتاح الذي تنشئه VMMap نفسها عند قبول اتفاقية الاستخدام تحت HKCU\Software\Sysinternals\VMMap، وتستطيع أن تحذفه إذا لم تعد تستعمل الأداة.
الخلاصة Summary
- الحجز يسجل عناوين فقط ولا يكلف شيئاً، وقد حجزنا 100 TB في 0.01 ms، والتثبيت وعد يحسب على حد الجهاز فوراً ويظهر في Private Bytes، والصفحة الحقيقية لا تولد إلا عند أول لمسة.
- Windows يعطي صفحة حقيقية مصفرة عند أول قراءة أيضاً، وكل خطأ صفحة كلف حوالي 0.6 ميكروثانية في المختبر، والوصول إلى ما لم يثبت ينتهي بالرمز
0xC0000005. - Working Set هو ما في RAM الآن، والتقليم ينقل الصفحات إلى قوائم Modified وStandby دون أن تفقد، وتعود بخطأ خفيف، و«المتاحة» في Windows أغلبها ذاكرة مؤقتة مفيدة.
- حد التثبيت هو RAM مع ملف الصفحات، والخطأ 1455 يعني أن الوعود وصلت إلى الحد، وملف الصفحات الذي يديره النظام يكبر عند الحاجة فيتحرك الحد.
- القسم Section ذاكرة واحدة في عدة عمليات تحسب مرة واحدة، والنسخ عند الكتابة يثبت مسبقاً كل صفحة قد تصبح خاصة، وحد الـ Job يرفض الطلبات ولا يقتل العملية.
- VMMap تجمع كل هذه الأرقام لعملية واحدة، وهي أول أداة تفتحها عندما تشك في تسرب ذاكرة.
وفي المقال التالي من هذه المرحلة ننتقل من الذاكرة إلى الكائنات التي تمسكها: المقابض Handles ومدير الكائنات Object Manager، وكيف تجد عمليتان الكائن نفسه بالاسم، ومن يقرر من يحق له أن يفتحه.
سجل التحديثات Changelog
- نوفمبر 2026: كتابة المقال، وتشغيل المختبر على Windows 11 Pro 24H2 (البناء 26100.9711) بـ Windows PowerShell 5.1 وصلاحيات مستخدم عادي، مع البرنامج
mem.exeمبنياً بـ MinGW-w64 GCC 14.2.0 في Container من alpine:3.22، وVMMap 3.4 من Sysinternals.