إذا كنت تدير سيرفر Windows يشغل تطبيق ويب لعملائك، ويشغل في الليل على الجهاز نفسه مهمة ثقيلة، مثل ضغط النسخ الاحتياطية Backup أو بناء تقارير من قاعدة البيانات، فغالب الظن أنك رأيت هذا المشهد: يبطؤ التطبيق كلما بدأت المهمة، فتفتح مدير المهام Task Manager وتخفض أولوية المهمة إلى Low، فيتحسن الوضع قليلاً، ثم تكتشف في الليلة التالية أن المهمة شغلت برامج أخرى لم تنخفض أولويتها، وأن بعض هذه البرامج بقي يعمل بعد أن أنهيت المهمة الأصلية. والسؤال الذي يطرحه أي مسؤول في هذه اللحظة: كيف يقرر Windows أي برنامج يأخذ المعالج الآن؟ وما الذي تغيره الأولوية فعلاً؟ وهل توجد طريقة تضع سقفاً حقيقياً لمجموعة كاملة من البرامج، فلا تأخذ أكثر من نسبة محددة مهما شغلت من عمليات أبناء؟
والإجابة تمر بثلاثة مفاهيم في قلب Windows: العملية Process، والخيط Thread، وكائن المهمة Job Object. وهذا المقال هو الأول في مرحلة Windows من الداخل Windows Internals، ويسير على خطى كتاب Windows Internals في طبعته السابعة (Yosifovich وIonescu وRussinovich وSolomon)، ولكننا لا نكتفي بما يقوله الكتاب، وإنما نكتب برامج صغيرة بلغة C ونشغلها على جهاز Windows 11 حقيقي دون صلاحيات المدير Administrator، ونقرأ الأرقام التي تعطيها النواة Kernel لكل سؤال. وقد شرحنا في مقال Win32 للعمليات والملفات كيف ينشئ البرنامج عملية بالدالة CreateProcessW ويقرأ مخرجها ويورثها المقابض، فلن نعيد ذلك هنا، وإنما نبدأ من النقطة التي انتهى عندها: ماذا يحدث للعملية والخيط بعد أن يولدا؟
دليلWin32 للعمليات والملفات: CreateProcess وCreateFileنشغل برامج أخرى ونقرأ مخرجها ونفتح الملفات بلغة C على Windows 11 بصلاحيات مستخدم عادي، ونرى لماذا تتجمد الأدوات مع الأنابيب ولماذا يبقى الملف مفتوحاً بعد أن تغلقه.
دليلمدير الذاكرة في Windows: Working Set وملف Pagefileنقيس على Windows 11 بصلاحيات مستخدم عادي الفرق بين حجز الذاكرة وتثبيتها ولمسها، ونرى أين تذهب الصفحة بعد التقليم ومن أين يأتي الخطأ 1455 وماذا يفعل ملف الصفحات فعلاً.
دليلالمقابض Handles والكائنات Objects في Windowsنفتح الرقم الذي يعطيه Windows لبرنامجك عند كل فتح ونرى ما خلفه بلغة C وWinObj على Windows 11 دون صلاحيات المدير: أين تعيش الأسماء، ومتى يموت الكائن، ومن يحق له فتحه، وكم يكلف المقبض الذي لا يغلق.
دليلرموز الأمان Tokens وقوائم ACL والتحكم UAC في Windowsنقرأ رمز الأمان الذي يحمله كل برنامج على Windows 11 ونستعمله ببرنامج C دون رفع الصلاحيات، لنفهم لماذا يرفض Windows حساب المدير، وكيف يمنع مستوى Low الكتابة، وكيف تقرر قوائم ACL.وسوف نناقش في هذا المقال ما يلي:
- ما هي العملية والخيط في نظر النواة: الهياكل EPROCESS وETHREAD، وما تراه أنت منها في ذاكرة برنامجك عبر PEB وTEB.
- كم يكلف إنشاء عملية مقابل إنشاء خيط، بالأرقام من جهاز حقيقي.
- مستويات الأولوية من 0 إلى 31، وكيف تتكون من فئة العملية Priority Class وأولوية الخيط النسبية، والدفعة المؤقتة Priority Boost.
- الكوانتم Quantum: كم يعمل الخيط قبل أن يأخذ غيره المعالج، وماذا يحدث لخيط أقل بدرجة واحدة فقط.
- دقة المؤقت Timer Resolution ولماذا ينتظر
Sleep(1)أكثر من 15 ms، والتغيير الذي جاء مع Windows 11. - النسيج Fiber مقابل الخيط: كم يكلف التبديل بينهما، ولماذا لا ننصح به اليوم.
- كائنات المهمة Job Objects: سقف المعالج، وحد عدد العمليات، وإنهاء شجرة العمليات كاملة.
- الأخطاء الشائعة، وجدول قرار، وتدريب عملي.
العملية والخيط في نظر النواة
العملية في Windows حاوية للموارد ولا تنفذ شيئاً بنفسها: فيها مساحة عناوين Address Space خاصة، وجدول مقابض Handle Table، ورمز أمان Access Token، وقائمة بخيوطها. والخيط هو الشيء الوحيد الذي يجدوله المجدول Scheduler، أي أن النواة لا تقرر أي عملية تعمل، وإنما أي خيط يعمل على كل معالج منطقي Logical Processor في كل لحظة. لذلك عندما تقول إن البرنامج يستهلك 25% من المعالج، فالدقيق أن خيطاً واحداً أو أكثر من خيوطه كانت في حالة التشغيل Running لهذا الجزء من الوقت.
وداخل النواة يمثل Windows كل عملية بهيكل اسمه EPROCESS، وفي أوله هيكل أصغر اسمه KPROCESS يحمل ما يحتاجه المجدول فقط، مثل الأولوية الأساسية Base Priority للعملية والمعالجات المسموح لها Affinity. وكل خيط يمثله هيكل ETHREAD وفي أوله KTHREAD، وفيه حالة الخيط (جاهز Ready، أو يعمل Running، أو ينتظر Waiting) وأولويته الحالية وما بقي له من الكوانتم ومكدس النواة Kernel Stack الخاص به. وهذه الهياكل في ذاكرة النواة، فلا يقرؤها برنامج عادي، ويشرحها كتاب Windows Internals في الجزء الأول، الفصل الثالث للعمليات والمهام والفصل الرابع للخيوط، مع أوامر المنقح WinDbg التي تعرضها من ملف تفريغ أو من جهاز في وضع تنقيح النواة.
ولكن جزءاً من هذه المعلومات تحتاجه مكتبات وضع المستخدم User Mode في كل لحظة، مثل ntdll.dll وkernelbase.dll، ولو طلبته من النواة كل مرة لكلف ذلك استدعاء نظام System Call. لذلك تضع النواة نسخة منه في ذاكرة العملية نفسها في هيكلين: PEB واختصاراً Process Environment Block، وهو واحد لكل عملية، وTEB واختصاراً Thread Environment Block، وهو واحد لكل خيط. وتوثق Microsoft من الهيكلين الحقول التي تضمن بقاءها فقط، وتنبه إلى أن الباقي قد يتغير بين الإصدارات، ولذلك فإن الكود في المختبر يقرأ بإزاحات Offsets ثابتة على Windows 11 بنسخة 64 بت للتعليم فقط، ولا يصح أن تبني عليه برنامجاً للإنتاج.
تجهيز المختبر Lab
المختبر ستة برامج صغيرة بلغة C، كل منها يجيب عن سؤال واحد: inside.exe يقرأ الـ PEB والـ TEB، وcreate.exe يقيس كلفة الإنشاء، وsched.exe يقيس الأولوية والكوانتم والمؤقت، وfiber.exe يقارن الخيوط بالنسيج، وjob.exe يجرب كائنات المهمة، وspin.exe برنامج يشغل المعالج أو ينام أو يشغل حفيداً، وتستعمله البرامج الأخرى ابناً لها. ولا نحتاج إلى تثبيت أي مترجم على Windows، فالبناء بمترجم MinGW-w64 GCC داخل Container مؤقت من Alpine يحذف نفسه بعد الانتهاء:
docker run --rm -v "%cd%:/src" -w /src alpine:3.22 sh build.shوالملف build.sh يثبت المترجم داخل الـ Container ثم يبني البرامج الستة:
#!/bin/sh
# Builds the lab programs 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
CC="x86_64-w64-mingw32-gcc -O1 -Wall"
$CC -o build/spin.exe spin.c
$CC -o build/inside.exe inside.c -lpsapi
$CC -o build/create.exe create.c
$CC -o build/sched.exe sched.c -lwinmm
$CC -o build/fiber.exe fiber.c -lpsapi
$CC -o build/job.exe job.c
ls -l buildثم يشغل السكربت run.ps1 في Windows PowerShell 5.1 الملفات المرقمة بالترتيب، وكل ملف يكتب مخرجه في ملف out-*.txt بجانبه بعد أن يستبدل اسم المستخدم واسم الجهاز ومسار المجلد بأسماء عامة مثل C:\lab:
powershell -NoProfile -ExecutionPolicy Bypass -File run.ps1والسكربت لا يحتاج صلاحيات المدير، ولا يغير شيئاً في السجل Registry ولا في إعدادات النظام، وكل ما ينشئه في مجلد واحد داخل %TEMP% يحذفه السكربت الأخير 99-cleanup.ps1، ويستدعي في البداية الدالة SetErrorMode حتى لا تظهر أي نافذة خطأ على سطح المكتب إذا سقط برنامج. ولاحظ أن الحساب الذي شغلنا به المختبر حساب مدير يعمل دائماً بالرمز المحدود الذي يعطيه التحكم بحساب المستخدم UAC، أي أن البرامج تعمل بمستوى السلامة المتوسط Medium Integrity وبصلاحيات المستخدم العادي، وقد خصصنا لهذا الموضوع مقال رموز الأمان في هذه المرحلة. وهذه بيئة التشغيل كما طبعها السكربت الأول:
OS : Microsoft Windows 11 Pro (build 26100.9711)
CPU : Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz, 4 cores, 8 logical processors
PowerShell: 5.1.26100.9711
Elevated : False
Lab folder: C:\lab
create.exe 67178 bytes
fiber.exe 66944 bytes
inside.exe 65963 bytes
job.exe 74585 bytes
sched.exe 75806 bytes
spin.exe 64931 bytesالتجربة الأولى: ماذا ترى العملية عن نفسها؟
البرنامج inside.exe يقرأ عنوان الـ TEB الخاص بالخيط الحالي بالدالة NtCurrentTeb، ثم يقرأ منه بعض الحقول، وينشئ خيطاً ثانياً يفعل الشيء نفسه، ثم يقرأ من الـ PEB معلومات العملية. والجزء الذي يقرأ الـ TEB هو الدالة التالية:
#define AT(p, off, T) (*(T *)((BYTE *)(p) + (off)))
typedef struct { USHORT Length, MaximumLength; PWSTR Buffer; } USTR;
static void show_teb(const char *who) {
BYTE *teb = (BYTE *)NtCurrentTeb();
printf("%s: TEB %p ClientId pid %llu tid %llu stack %p..%p (%llu KB committed so far)\n", who, teb,
(ULONGLONG)AT(teb, 0x40, ULONG_PTR), (ULONGLONG)AT(teb, 0x48, ULONG_PTR),
AT(teb, 0x10, void *), AT(teb, 0x08, void *), (ULONGLONG)(AT(teb, 0x08, BYTE *) - AT(teb, 0x10, BYTE *)) / 1024);
printf("%s: PEB pointer in TEB %p, LastError slot %lu\n", who, AT(teb, 0x60, void *), AT(teb, 0x68, DWORD));
}
static DWORD WINAPI worker(LPVOID p) { (void)p; show_teb("thread 2"); return 0; }وعند تشغيله كان المخرج كما يلي:
> inside.exe --hello
API : GetCurrentProcessId 39312, GetCurrentThreadId 20412
thread 1: TEB 000000C30D818000 ClientId pid 39312 tid 20412 stack 000000C30DBFC000..000000C30DC00000 (16 KB committed so far)
thread 1: PEB pointer in TEB 000000C30D817000, LastError slot 126
thread 2: TEB 000000C30D81C000 ClientId pid 39312 tid 28504 stack 000000C30DFFE000..000000C30E000000 (8 KB committed so far)
thread 2: PEB pointer in TEB 000000C30D817000, LastError slot 187
PEB : BeingDebugged 0, ImageBaseAddress 00007FF620280000 (GetModuleHandle(NULL) 00007FF620280000)
PEB : NumberOfProcessors 8, OS 10.0 build 26100, SessionId 1
PEB : ImagePathName C:\lab\inside.exe
PEB : CommandLine "C:\lab\inside.exe" --hello
PEB : CurrentDir C:\lab\
NtQueryInformationProcess: status 0x00000000, PebBaseAddress 000000C30D817000, parent pid 42964, base priority 8
NtQueryInformationThread : TebBaseAddress 000000C30D818000, current priority 9, BasePriority field (increment over the process base) 0
cost: GetCurrentProcessId 1.1 ns/call, NtQueryInformationProcess 662.1 ns/call (1000000 calls each)
process: 61 handles, private 572 KB, working set 3872 KB
[exit code 0 = 0x00000000]وفي المخرج أعلاه لاحظ التالي:
- كل خيط له TEB خاص به: الخيط الأول في عنوان ينتهي بـ
818000والثاني في81C000، وفي كل واحد رقم العملية نفسه 39312 ورقم خيط مختلف، وهذا ما يسمى معرف العميل ClientId في الهيكل. - والـ PEB واحد للاثنين: الخيطان يشيران إلى العنوان نفسه
000000C30D817000، وهو العنوان نفسه الذي أعادته الدالةNtQueryInformationProcessمن النواة في الحقلPebBaseAddress. فالنواة هي التي تنشئ الـ PEB عند إنشاء العملية وتملؤه، ثم تتركه في ذاكرة العملية لتقرأه مكتباتها. - المكدس Stack لكل خيط في مكان مختلف: وكل منهما بدأ صغيراً، 16 KB للأول و8 KB للثاني، لأن Windows يحجز للمكدس مساحة كبيرة (1 MB افتراضياً من ترويسة الملف التنفيذي) ولكنه لا يخصص منها إلا ما يستعمله الخيط فعلاً، وهذا الفرق بين الحجز Reserve والتخصيص Commit موضوع مقال مدير الذاكرة في هذه المرحلة.
- خانة LastError في الـ TEB: قيمتها 126 في الخيط الأول و187 في الثاني. وهذه هي القيمة التي تعيدها الدالة
GetLastError، فهي لا تسأل النواة، وإنما تقرأ هذه الخانة من TEB الخيط الذي يستدعيها. لذلك كل خيط له آخر خطأ خاص به، ولا يفسد خيط قيمة غيره، وهذا هو السبب الذي جعلGetLastErrorتعمل بأمان في البرامج متعددة الخيوط منذ Windows NT. أما الرقمان نفسهما فهما بقايا محاولات فاشلة صامتة داخل المحمل Loader والمكتبات أثناء التشغيل، وهذا يؤكد القاعدة التي شرحناها في مقال واجهة Win32: لا تقرأGetLastErrorإلا بعد أن تفشل الدالة. - الـ PEB يحمل سطر الأوامر والمجلد الحالي ومسار البرنامج: فالدالة
GetCommandLineWمثلاً لا تكلم النواة، وإنما تعيد مؤشراً إلى هذا النص في الـ PEB. وفيه أيضاً عدد المعالجات 8 ورقم الإصدار 26100 والجلسة Session 1. - العملية الأب Parent: النواة تحفظ في
EPROCESSرقم العملية التي أنشأتها، ورأيناه هنا 42964، وهو برنامج PowerShell الذي شغل التجربة. ولاحظ أن هذا رقم فقط، فإذا انتهت العملية الأب قد يعطي Windows الرقم نفسه لعملية أخرى لاحقاً.
والسطر قبل الأخير هو أهم رقم في التجربة: قراءة رقم العملية بالدالة GetCurrentProcessId كلفت 1.1 ns لأنها تقرأ الـ TEB فقط، بينما كلف استدعاء NtQueryInformationProcess، الذي يعبر إلى النواة ويعود، 662 ns في المتوسط لمليون استدعاء، أي قرابة 600 ضعف. وهذا هو السبب الذي جعل مصممي Windows يضعون نسخة من المعلومات المتكررة في ذاكرة العملية، وقد شرحنا كلفة العبور إلى النواة بالتفصيل في مقال فضاء النواة والمستخدم.

BeingDebugged في الـ PEB هو ما تقرؤه الدالة IsDebuggerPresent، ولذلك فإن البرامج التي تحاول منع التنقيح بهذا الفحص يسهل خداعها، لأن الـ PEB في ذاكرة العملية نفسها ويستطيع المنقح أن يغيره. ولا تعتمد على هذا الفحص لحماية أي شيء مهم.كم يكلف إنشاء عملية مقابل خيط؟
الآن نعود إلى المهمة الليلية التي بدأنا بها. فبعض أدوات الضغط والتقارير تشغل عملية جديدة لكل ملف أو لكل جزء من العمل، وبعضها يستعمل خيوطاً داخل عملية واحدة. والفرق بين الطريقتين ليس في الأداء فقط، ولكن لنبدأ بالأداء. البرنامج create.exe ينشئ 200 عملية من spin.exe تخرج فور بدايتها، وينتظر كل واحدة حتى تنتهي، ثم ينشئ 2000 خيط لا تفعل شيئاً وينتظر كل واحد منها. والمخرج سوف يكون كما يلي:
> create.exe 200 2000
process: 200 x CreateProcess + wait for exit: first 52.63 ms, average 30.245 ms, median 26.752 ms, p99 80.328 ms
thread : 2000 x CreateThread + wait for exit: average 0.1229 ms, median 0.1172 ms, p99 0.2976 ms
[exit code 0 = 0x00000000]وفي المخرج أعلاه لاحظ التالي:
- الخيط كلف 0.117 ms في الوسيط، أي قرابة 117 ميكروثانية لإنشاء خيط وتشغيله وانتظار خروجه وإغلاق مقبضه.
- العملية كلفت 26.75 ms في الوسيط، أي قرابة 230 ضعف الخيط، والأولى كانت الأبطأ بـ 52.6 ms.
- التفاوت كبير في العمليات: النسبة المئوية 99 Percentile بلغت 80 ms، بينما بقي الخيط تحت 0.3 ms.
وقد يتساءل البعض: لماذا هذا الفرق الكبير، والعملية في النهاية كائن في النواة مثل الخيط؟ والإجابة أن إنشاء الخيط يعني إنشاء ETHREAD وTEB ومكدس داخل عملية جاهزة، بينما إنشاء العملية يعني فتح الملف التنفيذي وإنشاء قسم Section له، ومساحة عناوين جديدة، وPEB، ثم تشغيل المحمل في العملية الجديدة ليحمل ntdll.dll وkernel32.dll وkernelbase.dll ومكتبة C ويهيئها، وإخبار النظام الفرعي Win32 في csrss.exe بالعملية الجديدة، وفي برامج الطرفية Console تشغيل عملية مضيف الطرفية conhost.exe معها، كما سوف نرى بأعيننا في تجربة المهام. وعلى أي جهاز حقيقي قد يضيف برنامج الحماية وقتاً آخر، لأن مكافح الفيروسات يفحص الملف التنفيذي عند فتحه، ولم نقس هذا الجزء وحده في المختبر. والمسار الكامل لدالة CreateProcess داخل النواة مشروح في الفصل الثالث من Windows Internals في سبع مراحل، من التحقق من المعاملات إلى بدء الخيط الأول.

فهل يعني هذا أن تستعمل الخيوط دائماً؟ لا، والتفصيل فيما يلي: العملية تعطيك عزلاً Isolation لا يعطيه الخيط، فإذا سقط خيط واحد سقطت العملية كلها بكل خيوطها، وإذا سقطت عملية ابن بقي الأب سليماً. لذلك تقسم المتصفحات الحديثة كل موقع إلى عملية مستقلة، ويشغل IIS كل تطبيق في مجمع تطبيقات Application Pool بعملية خاصة به. والقاعدة العملية: استعمل العمليات حدوداً للعزل والأمان، واستعمل الخيوط، والأفضل مجمع الخيوط Thread Pool الذي يوفره Windows، للعمل المتوازي داخل حدود العزل نفسها. ولا تنشئ عملية جديدة لكل طلب صغير، لأن 27 ms لكل طلب تعني أنك لن تخدم أكثر من بضع عشرات من الطلبات في الثانية على كل معالج.
الأولوية: من 0 إلى 31
يعطي Windows كل خيط رقماً بين 0 و31 يسمى الأولوية، وتشرح Microsoft في صفحة Scheduling Priorities القاعدة الأساسية: يحتفظ المجدول بطابور Queue للخيوط الجاهزة لكل مستوى، ويعطي المعالج دائماً لخيط من أعلى طابور فيه خيط جاهز، ولا ينظر إلى المستوى الأدنى ما دام في الأعلى خيط ينتظر. فالأولوية في Windows ليست نسبة من الوقت كما في المجدول العادل CFS في Linux، وإنما ترتيب صارم، وقد شرحنا طريقة Linux المختلفة في مقال العمليات وجدولة المعالج في Linux.
ولكن البرنامج لا يكتب الرقم مباشرة، وإنما يختار شيئين: فئة الأولوية Priority Class للعملية كلها بالدالة SetPriorityClass، وأولوية نسبية Relative Priority لكل خيط بالدالة SetThreadPriority، والنواة تجمعهما في رقم واحد هو الأولوية الأساسية Base Priority. والبرنامج sched.exe في الوضع prio يجرب كل الفئات الست مع كل القيم النسبية السبع على خيط ينتظر، ويقرأ الرقم الناتج من النواة بالدالة NtQueryInformationThread:
> sched.exe prio
asked class got class IDLE LOWEST BELOW NORMAL ABOVE HIGHEST TIME_CRITICAL
IDLE IDLE 1 2 3 4 5 6 15
BELOW_NORMAL BELOW_NORMAL 1 4 5 6 7 8 15
NORMAL NORMAL 1 6 7 8 9 10 15
ABOVE_NORMAL ABOVE_NORMAL 1 8 9 10 11 12 15
HIGH HIGH 1 11 12 13 14 15 15
REALTIME HIGH 1 11 12 13 14 15 15
[exit code 0 = 0x00000000]وفي الجدول أعلاه لاحظ التالي:
- كل فئة لها مركز: NORMAL مركزها 8، وBELOW_NORMAL مركزها 6، وIDLE مركزها 4، وABOVE_NORMAL مركزها 10، وHIGH مركزها 13. والقيم النسبية من LOWEST إلى HIGHEST تضيف إلى المركز من 2- إلى 2+.
- القيمتان الطرفيتان لا تتبعان الفئة:
THREAD_PRIORITY_IDLEتعطي 1 دائماً، وTHREAD_PRIORITY_TIME_CRITICALتعطي 15 دائماً، في كل الفئات المتغيرة. فخيط TIME_CRITICAL في عملية IDLE يسبق كل خيوط العمليات العادية. - المستوى 0 غير موجود في الجدول: فهو محجوز لخيط في النواة اسمه خيط الصفحات الصفرية Zero Page Thread، يملأ صفحات الذاكرة الحرة بالأصفار عندما لا يكون لدى المعالج شيء آخر يفعله.
- REALTIME لم يعمل، ولم تفشل الدالة: السطر الأخير طلب
REALTIME_PRIORITY_CLASSفأعادتSetPriorityClassنجاحاً، ولكن الفئة التي قرأناها بعدها كانت HIGH، والأرقام هي أرقام HIGH نفسها. والسبب أن الدخول إلى المستويات من 16 إلى 31 يحتاج امتيازSeIncreaseBasePriorityPrivilege، والرمز الذي نعمل به لا يملكه، فتعطي النواة أعلى ما يسمح به بصمت. وهذا يعني أن البرنامج الذي يكتب في سجلاته أنه يعمل بأولوية الوقت الحقيقي قد يكون كاذباً دون أن يعلم، فإذا كانت الأولوية مهمة لك فاقرأها بعد أن تضبطها.

والمستويات من 16 إلى 31 تسمى مستويات الوقت الحقيقي Real-time، وهي ليست وقتاً حقيقياً بمعنى الأنظمة المدمجة التي تضمن زمن الاستجابة، وإنما مستويات لا يغيرها Windows أبداً، بينما المستويات من 1 إلى 15 تسمى المستويات المتغيرة Dynamic Levels لأن النواة ترفع الخيط فيها مؤقتاً ثم تعيده. ولا تضع برنامجاً عادياً في فئة REALTIME حتى لو كنت مديراً، والسبب أن خيوطاً مهمة في Windows نفسه، مثل خيوط إدخال لوحة المفاتيح والفأرة وتحديث الشاشة، تعمل في مستويات أدنى من 31، فخيط واحد مشغول في هذه الفئة قد يجعل الجهاز لا يستجيب للفأرة.
الدفعة المؤقتة Priority Boost
تقول Microsoft في صفحة Priority Boosts إن لكل خيط أولوية حالية Dynamic Priority تبدأ مساوية للأساسية، وإن المجدول يرفعها في ثلاث حالات: عندما تصبح عملية بفئة NORMAL في الواجهة Foreground، وعندما تصل رسالة إدخال إلى نافذة الخيط، وعندما ينتهي انتظار الخيط لحدث أو لعملية إدخال وإخراج I/O. ثم ينقصها درجة كل كوانتم حتى تعود إلى الأساسية. والوضع boost في البرنامج يوقظ خيطاً بأولوية أساسية 8 خمس مرات عبر حدث Event، ويقرأ الخيط أولويته الحالية لحظة استيقاظه، مرة والدفعة مفعلة ومرة بعد أن نلغيها بالدالة SetThreadPriorityBoost:
> sched.exe boost
boost enabled : current priority right after each of 5 wake-ups (base 8): 9 9 9 9 9
boost disabled: current priority right after each of 5 wake-ups (base 8): 8 8 8 8 8
[exit code 0 = 0x00000000]والنتيجة واضحة: الخيط استيقظ في كل مرة بأولوية 9، أي بدرجة واحدة فوق أساسه، وهذه الدفعة التي يعطيها Windows لمن انتهى انتظاره لحدث، وعندما ألغيناها استيقظ بأولويته الأساسية 8. والفكرة من الدفعة أن الخيط الذي كان ينتظر شيئاً غالباً يريد أن يعمل قليلاً ثم ينتظر مرة أخرى، مثل خيط واجهة يستقبل ضغطة زر، فإعطاؤه المعالج بسرعة يجعل البرنامج يبدو سريع الاستجابة دون أن يأخذ من غيره وقتاً كثيراً. وفي الصفحة نفسها توثق Microsoft أن خيوط المستويات من 16 إلى 31 لا تحصل على أي دفعة.
وهناك نوع آخر من الدفعات لا تراه في هذه التجربة، يسمى في وثيقة Priority Inversion بالاسم AutoBoost: عندما ينتظر خيط بأولوية عالية قفلاً Lock يملكه خيط بأولوية منخفضة، ترفع النواة صاحب القفل مؤقتاً إلى أولوية من ينتظره حتى يحرر القفل. والمشكلة التي يحلها هذا تسمى انقلاب الأولوية Priority Inversion، وقد ذكرنا في مقال جدولة Linux قصتها المشهورة مع المركبة Mars Pathfinder.
الكوانتم Quantum: كم يعمل الخيط قبل أن يتركه؟
إذا كان على المعالج نفسه خيطان جاهزان بالأولوية نفسها، فالمجدول يعطي الأول وقتاً محدداً يسمى الكوانتم Quantum، ثم ينقله إلى آخر الطابور ويعطي الثاني، وتذكر وثيقة Context Switches أن أشهر أسباب تبديل السياق Context Switch ثلاثة: انتهاء الكوانتم مع وجود خيط جاهز بالأولوية نفسها أو أعلى، أو جاهزية خيط بأولوية أعلى، أو انتظار الخيط الذي يعمل. ويقول كتاب Windows Internals إن الكوانتم في نسخ Windows للأجهزة المكتبية Client هو ساعتان Clock Intervals، والساعة الافتراضية 15.625 ms، أي قرابة 31 ms، ويطول في إصدارات الخوادم Server إلى 12 ساعة، ويتحكم فيه المفتاح Win32PrioritySeparation في السجل.
ولكي نرى ذلك بأعيننا، يثبت البرنامج sched.exe عمليته على معالج منطقي واحد هو الأخير بالدالة SetProcessAffinityMask، ويشغل خيطين مشغولين دائماً، كل منهما يقرأ ساعة الأداء العالي ويسجل اللحظة التي يأخذ فيها المعالج من الآخر. ونسمي المدة بين أن يأخذ الخيط المعالج وأن يأخذه الآخر منه نوبة Turn. وهذا قلب البرنامج:
static DWORD WINAPI busy(LPVOID p) {
int k = (int)(INT_PTR)p; SL *x = &s[k]; WaitForSingleObject(startev, INFINITE);
double t = now_ms(), last = t;
while (t < tend) {
t = now_ms();
if (owner != k) { // we just took the processor from the other thread
LONG o = owner;
if (o >= 0 && s[o].n < MAXS) { s[o].len[s[o].n] = tlast[o] - tbeg[o]; s[o].at[s[o].n] = tbeg[o] - t0; s[o].n++; }
owner = k; t = now_ms(); tbeg[k] = t; // t may be stale if we were switched out right after reading it
} else if (t - last > 0.5) x->other += t - last; // someone else (another process) ran in the middle of our turn
last = t; tlast[k] = t;
}
return 0;
}وشغلنا التجربة أربع مرات: خيطان متساويان في عملية بفئة NORMAL، ثم الشيء نفسه بفئة HIGH، ثم بفئة HIGH مع طلب ساعة 1 ms، ثم خيطان بينهما درجة واحدة فقط لمدة 12 ثانية:
> sched.exe slices 0 0 6
system timer at start 15.6250 ms
NORMAL class, pinned to logical processor 7 of 8; threads at relative priority +0 and +0 for 6 s
thread A (rel +0): CPU 2703 ms (45.1%), 797 turns, turn length median 2.0 ms, p10 2.0, p90 2.0, max 41.9; other processes inside its turns 22 ms
thread B (rel +0): CPU 3156 ms (52.6%), 797 turns, turn length median 2.0 ms, p10 2.0, p90 2.0, max 34.1; other processes inside its turns 23 ms
system timer at end 15.6250 ms
[exit code 0 = 0x00000000]
> sched.exe slices 0 0 6 high
system timer at start 15.6250 ms
HIGH class, pinned to logical processor 7 of 8; threads at relative priority +0 and +0 for 6 s
thread A (rel +0): CPU 2891 ms (48.2%), 815 turns, turn length median 2.0 ms, p10 2.0, p90 2.0, max 36.1; other processes inside its turns 2 ms
thread B (rel +0): CPU 3094 ms (51.6%), 816 turns, turn length median 2.0 ms, p10 2.0, p90 2.0, max 34.1; other processes inside its turns 0 ms
system timer at end 15.6250 ms
[exit code 0 = 0x00000000]
> sched.exe slices 0 0 6 high,1ms
system timer at start 1.0000 ms (this process asked for 1 ms)
HIGH class, pinned to logical processor 7 of 8; threads at relative priority +0 and +0 for 6 s
thread A (rel +0): CPU 2922 ms (48.7%), 815 turns, turn length median 2.0 ms, p10 2.0, p90 2.0, max 34.1; other processes inside its turns 0 ms
thread B (rel +0): CPU 3078 ms (51.3%), 816 turns, turn length median 2.0 ms, p10 2.0, p90 2.0, max 34.1; other processes inside its turns 1 ms
system timer at end 1.0000 ms
[exit code 0 = 0x00000000]في المخرج أعلاه لاحظ التالي:
- القسمة عادلة تقريباً: الخيطان المتساويان أخذ كل منهما قرابة النصف، 45% و53% في الفئة NORMAL، و48% و52% في الفئة HIGH. والفرق في NORMAL جاء من برامج أخرى على الجهاز شاركتنا المعالج نفسه، والسطر يقول إنها أخذت 22 ms و23 ms من داخل نوبات الخيطين، وعندما رفعنا الفئة إلى HIGH قلت هذه المقاطعات إلى ما يقارب الصفر.
- النوبة 2 ms وليست 31 ms: الوسيط والنسبتان 10 و90 كلها 2.0 ms، أي أن الخيطين تبادلا المعالج قرابة 800 مرة في 6 ثوان. وأطول نوبة كانت 34 ms إلى 42 ms، وهي قريبة من الرقم الذي يذكره الكتاب.
وهذا الرقم 2 ms فاجأنا أثناء كتابة المختبر، فالمفتاح Win32PrioritySeparation على الجهاز بقيمته الافتراضية 2، كما يبين السطر الأخير من المخرج، والقيمة الافتراضية تعني الكوانتم القصير المتغير. والتفسير الأقرب نجده في وثيقة timeBeginPeriod: فالساعة التي يعمل عليها المجدول تتسارع عندما يطلب أي برنامج على الجهاز دقة أعلى، وتقول الوثيقة صراحة إن الدقة الأعلى تجعل المجدول يبدل المهام أكثر. وعندما طلبنا نحن 1 ms في التجربة الثالثة أعطانا Windows 1.0000 ms بالضبط، وتقول الوثيقة نفسها إن العملية التي تطلب الدقة تحصل على أدق قيمة طلبتها أي عملية أخرى، فلو لم يكن على الجهاز برنامج آخر يطلب 1 ms لأعطانا 0.5 ms وهو الحد الأدنى الممكن. أي أن برنامجاً آخر على الجهاز كان يطلب 1 ms طوال الوقت، والساعة الفعلية تدق كل 1 ms، فالكوانتم بساعتين يصبح 2 ms. ولا تعرض Microsoft في وثائقها العامة رقم الكوانتم الحالي مباشرة، ولذلك نكتفي بالقول إن ما قسناه يتفق مع هذا التفسير، والدرس العملي أهم من الرقم: لا تبن منطق برنامجك على طول الكوانتم، فهو يتغير بإعداد الجهاز وبما يعمل عليه من برامج أخرى.
فرق درجة واحدة: التجويع Starvation
الآن نعود إلى المهمة الليلية. ماذا يحدث إذا رفعنا أحد الخيطين درجة واحدة فقط؟ التجربة الرابعة تشغل الخيط A بأولوية 14 والخيط B بأولوية 13 على المعالج نفسه لمدة 12 ثانية:
> sched.exe slices 1 0 12 high
system timer at start 15.6250 ms
HIGH class, pinned to logical processor 7 of 8; threads at relative priority +1 and +0 for 12 s
thread A (rel +1): CPU 11891 ms (99.1%), 6 turns, turn length median 2632.7 ms, p10 1580.6, p90 2642.0, max 2642.0; other processes inside its turns 10 ms
turns (start s : length ms): 0.00:32.1 0.06:2642.0 2.74:2632.7 5.40:2638.6 8.04:2374.0 10.42:1580.6
thread B (rel +0): CPU 94 ms (0.8%), 6 turns, turn length median 31.5 ms, p10 2.0, p90 32.1, max 32.1; other processes inside its turns 0 ms
turns (start s : length ms): 0.03:31.5 2.71:32.1 5.37:32.1 8.04:2.0 10.42:2.0 12.00:0.0
system timer at end 15.6250 ms
[exit code 0 = 0x00000000]في المخرج أعلاه لاحظ التالي:
- A أخذ 99.1% من المعالج: ست نوبات فقط في 12 ثانية، أغلبها بين 2.37 و2.64 ثانية متصلة. فدرجة واحدة كافية ليأخذ الخيط الأعلى كل شيء، وهذا ما تعنيه الأولوية الصارمة.
- B لم يمت جوعاً تماماً: أخذ 94 ms في 12 ثانية، على شكل نوبة كل 2.4 إلى 2.7 ثانية تقريباً، أول ثلاث منها بطول 32 ms تقريباً. وهذه هي دفعة مكافحة التجويع Starvation Boost: يمر مكون في النواة اسمه مدير التوازن Balance Set Manager على طوابير الخيوط الجاهزة كل ثانية، وإذا وجد خيطاً جاهزاً لم يعمل منذ مدة طويلة رفعه إلى 15 لكوانتم واحد. ويذكر الكتاب أن المدة نحو 4 ثوان، وقسناها هنا بين 2.4 و2.7 ثانية، فلا تعتمد على الرقم الدقيق.

وهذا يفسر ما رأيته في المهمة الليلية: إذا كانت المهمة بأولوية أعلى من تطبيقك، ولو بدرجة، وكانت مشغولة بالحساب، فتطبيقك على المعالجات التي تعمل عليها لا يحصل إلا على فتات كل ثانيتين أو أكثر. والعكس صحيح: إذا خفضت أولوية المهمة إلى BELOW_NORMAL أو IDLE فإن تطبيقك يسبقها دائماً، وهي لا تأخذ إلا ما يتركه. وهذا حل جيد عندما يكون هدفك ألا تؤذي المهمة التطبيق، ولكنه لا يضمن للمهمة أن تنتهي في وقتها إذا كان الجهاز مشغولاً، ولا يمنعها من أخذ كل المعالجات إذا كان الجهاز فارغاً، ولذلك نحتاج إلى أداة ثالثة سوف نصل إليها بعد قليل، وهي سقف المعالج في كائن المهمة.
مشكلة قابلتنا أثناء كتابة المختبر
النسخة الأولى من البرنامج أعطت لخيط B في التجربة الرابعة نوبات بطول 2.4 ثانية، أي بطول نوبات A نفسها، وهذا مستحيل على معالج واحد. والسبب كان في هذا السطر: كان الخيط يقرأ الساعة في المتغير t، ثم يفحص هل أخذ المعالج من الآخر، ثم يسجل بداية نوبته بقيمة t. فإذا أخذ المجدول المعالج منه بين القراءة والفحص، ثم أعاده بعد 2.4 ثانية، يسجل الخيط بداية نوبته بقيمة قديمة عمرها 2.4 ثانية. والحل الذي تراه في الكود أعلاه أن نقرأ الساعة مرة ثانية بعد أن نتأكد أننا أخذنا المعالج. وهذه مشكلة تتكرر في كل قياس أداء متعدد الخيوط: أي لحظة بين سطرين في كودك قد تكون ثانيتين في الواقع، لأن المجدول قد يأخذ المعالج منك في أي تعليمة.
والمشكلة الثانية أن الجهاز لم يكن فارغاً، فبرامج أخرى كانت تعمل على المعالج نفسه وتقطع نوبات الخيطين في الفئة NORMAL. وكان الحل أن نرفع العملية إلى الفئة HIGH في التجارب التي تقيس الكوانتم، فلا يقاطعها إلا ما هو أعلى منها، وأن نطبع الوقت الذي أخذته البرامج الأخرى داخل كل نوبة حتى يعرف القارئ كم الضجيج في القياس.
دقة المؤقت Timer Resolution: لماذا ينتظر Sleep(1) أكثر من 15 ms؟
الساعة التي يعتمد عليها المجدول هي الساعة نفسها التي توقظ الخيوط النائمة، ولذلك فإن الدالة Sleep(1) لا تعني ملي ثانية واحدة، وإنما تعني: أيقظني في أول دقة ساعة بعد ملي ثانية واحدة على الأقل. والوضع sleep في البرنامج يقرأ دقة الساعة بالدالة NtQueryTimerResolution، ثم يقيس Sleep(1) مئتي مرة في ثلاث حالات:
> sched.exe sleep
default : system timer 15.6250 ms (range 0.5000..15.6250); Sleep(1) x200: average 15.689 ms, median 15.727, max 16.695
timeBeginPeriod(1) : system timer 15.6250 ms (range 0.5000..15.6250); Sleep(1) x200: average 15.747 ms, median 15.806, max 19.692
SetProcessInformation(ProcessPowerThrottling, IGNORE_TIMER_RESOLUTION off): ok
timeBeginPeriod(1) + opt-out : system timer 1.0000 ms (range 0.5000..15.6250); Sleep(1) x200: average 1.821 ms, median 1.995, max 3.043
[exit code 0 = 0x00000000]في المخرج أعلاه لاحظ التالي:
- في الوضع الافتراضي كانت الساعة 15.625 ms، أي 64 دقة في الثانية، وانتظر
Sleep(1)في المتوسط 15.7 ms، أي أن برنامجاً يظن أنه ينام ملي ثانية واحدة 1000 مرة سوف ينام في الحقيقة قرابة 16 ثانية. - الدالة
timeBeginPeriod(1)لم تغير شيئاً: وهذه هي الطريقة التي تعلمها المطورون منذ عشرين سنة لطلب ساعة 1 ms. والسبب أن Windows 11 يتجاهل طلب الدقة من عملية لا يراها المستخدم ولا يسمعها، كما تقول وثيقةtimeBeginPeriod، وبرنامجنا يعمل دون نافذة. - بعد إلغاء التجاهل أصبح الانتظار 1.8 ms: استدعينا SetProcessInformation بالقيمة
ProcessPowerThrottlingمع العلمPROCESS_POWER_THROTTLING_IGNORE_TIMER_RESOLUTIONوقيمته صفر، وهذا يقول لـ Windows: لا تتجاهل طلبي حتى لو لم تكن لي نافذة ظاهرة. وبعدها أعطىtimeBeginPeriod(1)ساعة 1 ms، وأصبحSleep(1)بين 1 و2 ms.

فهل تطلب ساعة 1 ms في كل برامجك؟ لا تقم بذلك، والسبب أن الساعة الأسرع تمنع المعالج من دخول حالات توفير الطاقة العميقة، وتجعل المجدول يبدل المهام أكثر، وهذا ما رأيناه في نوبات 2 ms. وتنبه وثيقة timeBeginPeriod إلى أنها قد تقلل أداء النظام كله. والطريقة الصحيحة أن تطلب الدقة العالية قبل العمل الذي يحتاجها مباشرة، مثل تشغيل صوت أو لعبة، وأن تعيدها بالدالة timeEndPeriod فور انتهائه. وإذا كان كل ما تريده أن ينتظر خيطك حدثاً، فلا تستعمل Sleep في حلقة أبداً، وإنما انتظر الحدث نفسه بالدالة WaitForSingleObject، فهي توقظك فور حدوثه دون علاقة بدقة الساعة.
الخيوط والنسيج Fibers: من يقرر متى تنتقل؟
كل تبديل بين خيطين يمر بالنواة: يحفظ المجدول سياق الخيط الأول Context، أي قيم المسجلات Registers ومؤشر المكدس، ويختار التالي من الطوابير، ويعيد سياقه. وفي التسعينيات أضافت Microsoft إلى Windows NT 3.51 بديلاً أخف اسمه النسيج Fiber: وحدة تنفيذ لها مكدس وسياق، ولكنها تعيش داخل خيط واحد، والبرنامج نفسه هو الذي ينقل الخيط من نسيج إلى آخر بالدالة SwitchToFiber، فلا تعرف النواة عنها شيئاً. والبرنامج fiber.exe يقارن الطريقتين: خيطان يتبادلان الدور عبر حدثين 200,000 مرة، ثم نسيجان يتبادلان الدور 5,000,000 مرة، مرة على معالج واحد ومرة دون تثبيت:
> fiber.exe
pinned to one logical processor
threads: 200000 round trips in 800.2 ms = 2000 ns per switch (2 switches per round trip)
fibers : 5000000 round trips in 309.6 ms = 31.0 ns per switch (fiber counted 5000000)
memory : 1000 waiting threads +34220 KB private bytes (34.2 KB each); 1000 fibers that ran once +21288 KB (21.3 KB each)
[exit code 0 = 0x00000000]
> fiber.exe unpinned
not pinned (the two threads may run on different processors)
threads: 200000 round trips in 2982.0 ms = 7455 ns per switch (2 switches per round trip)
fibers : 5000000 round trips in 301.5 ms = 30.2 ns per switch (fiber counted 5000000)
[exit code 0 = 0x00000000]وفي المخرج أعلاه لاحظ التالي:
- تبديل الخيوط على معالج واحد كلف 2 ميكروثانية: وهذا يشمل
SetEventوWaitForSingleObjectوعبور النواة وتبديل السياق. - وعلى معالجين أصبح 7.5 ميكروثانية: أي أبطأ بثلاثة أضعاف وأكثر، لأن إيقاظ خيط على معالج آخر يحتاج مقاطعة بين المعالجات Inter-Processor Interrupt، وقد يكون المعالج الآخر في حالة توفير طاقة ويحتاج وقتاً ليستيقظ، والبيانات المشتركة تنتقل بين ذاكرتي التخزين المؤقت Cache للمعالجين. وهذه نتيجة تفاجئ كثيرين: إضافة معالجات لعمل يتبادل الرسائل بكثرة قد تجعله أبطأ.
- تبديل النسيج كلف 31 ns: أي أسرع من الخيوط على معالج واحد بستين ضعفاً، لأنه لا يعبر إلى النواة أصلاً، وهو حفظ مسجلات وتغيير مؤشر مكدس فقط.
- في الذاكرة: ألف خيط تنتظر أضافت 34.2 KB من الذاكرة الخاصة Private Bytes لكل خيط، وألف نسيج أضافت 21.3 KB لكل نسيج. والفرق أصغر مما يتوقعه البعض، لأن النسيج أيضاً يحتاج مكدساً حقيقياً.

فإذا كان النسيج بهذه السرعة، لماذا لا يستعمله أحد؟ والإجابة أن النواة لا تعرف عنه، فإذا قرأ نسيج ملفاً أو انتظر الشبكة توقف الخيط كله بكل أنسجته، وكل كود في المكتبات يفترض أن الخيط وحدة واحدة، مثل التخزين الخاص بالخيط Thread Local Storage والأقفال، قد يتصرف بشكل غريب مع الأنسجة. وقد كتب Raymond Chen مقالاً عنوانه Fibers aren't useful for much any more يشرح فيه أن أغلب من تحمسوا للنسيج عند ظهوره تركوه، لأنه يجعل الكود غير المتزامن يبدو متزامناً، وهذا ما يعده المجتمع اليوم عيباً لا ميزة. وكان أشهر مستخدم له SQL Server بخيار lightweight pooling، وتنصح Microsoft في صفحة الخيار نفسه بعدم تفعيله في أغلب الحالات. وأما البديل الأحدث الذي أضافته Microsoft في Windows 7، وهو الجدولة في وضع المستخدم User-Mode Scheduling، فقد أزيل تماماً، وتقول صفحته إن كل استدعاءاته تفشل في Windows 11 بالخطأ ERROR_NOT_SUPPORTED. والخلاصة العملية: إذا أردت آلاف المهام الصغيرة المتزامنة فاستعمل مجمع الخيوط أو async/await في لغتك، وقد قارنا هذه الطرق في مقال الخيوط وasync/await.
كائنات المهمة Job Objects: حدود لمجموعة عمليات
نعود الآن إلى المشكلة الأصلية بكل أجزائها: مهمة ليلية تشغل عمليات أبناء، والأولوية لا تنتقل دائماً إلى الأبناء بالشكل الذي تريده، والأبناء يبقون بعد إنهاء الأب، ولا يوجد سقف يقول: هذه المجموعة لا تأخذ أكثر من 20% من الجهاز. وهذا بالضبط ما صمم له كائن المهمة Job Object: كائن في النواة تضع فيه عملية أو أكثر، فيطبق Windows عليها حدوداً مشتركة، ويضع فيه تلقائياً كل عملية تنشئها عملية داخله، ويجمع لها محاسبة Accounting واحدة، وينهيها كلها بأمر واحد. وكائنات المهمة هي ما يبني عليه Windows أشياء كثيرة لا تراها: فمتصفح Chromium يضع كل عملية عرض Renderer في مهمة تمنعها من إنشاء عمليات أخرى، كما يشرح تصميم الصندوق المعزول Sandbox في Chromium، وحاويات Windows Containers تبنى على المهام مع امتداد في النواة اسمه الصومعة Silo، يشرحه الفصل الثالث من Windows Internals.
هل برنامجك داخل مهمة أصلاً؟
قبل أن تضع برنامجك في مهمة، اعرف هل هو في مهمة أخرى، لأن بعض الطرفيات وبيئات التطوير وخدمات التشغيل تضع البرامج التي تشغلها في مهام خاصة بها. والسطر الأول من التجربة يسأل النواة بالدالة IsProcessInJob:
> job.exe injob
job.exe inside a job: no
[exit code 0 = 0x00000000]البرنامج على هذا الجهاز ليس في مهمة. ولو كان في مهمة فلا مشكلة منذ Windows 8، لأن Windows يدعم المهام المتداخلة Nested Jobs، فتصبح مهمتك الجديدة ابناً للمهمة الموجودة، وتطبق على عملياتك حدود المهمتين معاً. وقبل Windows 8 كانت محاولة وضع عملية في مهمة ثانية تفشل، وكانت هذه مشكلة مشهورة مع أدوات البناء التي تعمل داخل خدمات التكامل المستمر CI.
سقف المعالج CPU Rate Control
الجزء التالي من job.c ينشئ مهمة، ويضع لها سقفاً صلباً Hard Cap بالهيكل JOBOBJECT_CPU_RATE_CONTROL_INFORMATION، ثم ينشئ نسخاً من spin.exe معلقة Suspended، ويضعها في المهمة قبل أن تبدأ، ثم يطلقها ويقيس الوقت الذي استهلكته من محاسبة المهمة نفسها:
static void cap(int percent, int secs, int n) {
HANDLE job = CreateJobObjectW(NULL, NULL);
if (percent) {
JOBOBJECT_CPU_RATE_CONTROL_INFORMATION r = {0};
r.ControlFlags = JOB_OBJECT_CPU_RATE_CONTROL_ENABLE | JOB_OBJECT_CPU_RATE_CONTROL_HARD_CAP; r.CpuRate = percent * 100; // units of 1/100 percent
if (!SetInformationJobObject(job, JobObjectCpuRateControlInformation, &r, sizeof r)) printf("SetInformationJobObject failed, error %lu\n", GetLastError());
}
char a[32]; snprintf(a, sizeof a, "%d", secs); PROCESS_INFORMATION pi[16]; HANDLE hp[16];
for (int i = 0; i < n; i++) { pi[i] = start(a, TRUE); AssignProcessToJobObject(job, pi[i].hProcess); hp[i] = pi[i].hProcess; }
double t0 = now_ms(); for (int i = 0; i < n; i++) ResumeThread(pi[i].hThread);
WaitForMultipleObjects(n, hp, TRUE, INFINITE); double wall = now_ms() - t0;
JOBOBJECT_BASIC_ACCOUNTING_INFORMATION acc; QueryInformationJobObject(job, JobObjectBasicAccountingInformation, &acc, sizeof acc, NULL);
double cpu = (acc.TotalUserTime.QuadPart + acc.TotalKernelTime.QuadPart) / 1e4;
SYSTEM_INFO si; GetSystemInfo(&si);
printf("cap %3d%%: %d spinning process(es), wall %.0f ms, job CPU %.0f ms = %.2f cores = %.1f%% of the %lu logical processors\n",
percent, n, wall, cpu, cpu / wall, cpu * 100 / wall / si.dwNumberOfProcessors, si.dwNumberOfProcessors);
for (int i = 0; i < n; i++) { CloseHandle(pi[i].hThread); CloseHandle(pi[i].hProcess); }
CloseHandle(job);
}ولاحظ أننا ننشئ العملية معلقة ثم نضعها في المهمة ثم نطلقها، ولو أطلقناها أولاً لكان أمامها وقت قصير تعمل فيه خارج المهمة، وقد تنشئ في هذا الوقت ابناً يهرب من المهمة إلى الأبد. وشغلنا الدالة خمس مرات، والمخرج سوف يكون كما يلي:
> job.exe cap 0 5 1
cap 0%: 1 spinning process(es), wall 5023 ms, job CPU 4984 ms = 0.99 cores = 12.4% of the 8 logical processors
[exit code 0 = 0x00000000]
> job.exe cap 20 5 1
cap 20%: 1 spinning process(es), wall 5019 ms, job CPU 4969 ms = 0.99 cores = 12.4% of the 8 logical processors
[exit code 0 = 0x00000000]
> job.exe cap 5 5 1
cap 5%: 1 spinning process(es), wall 5213 ms, job CPU 2219 ms = 0.43 cores = 5.3% of the 8 logical processors
[exit code 0 = 0x00000000]
> job.exe cap 0 5 4
cap 0%: 4 spinning process(es), wall 5064 ms, job CPU 18094 ms = 3.57 cores = 44.7% of the 8 logical processors
[exit code 0 = 0x00000000]
> job.exe cap 20 5 4
cap 20%: 4 spinning process(es), wall 5032 ms, job CPU 8672 ms = 1.72 cores = 21.5% of the 8 logical processors
[exit code 0 = 0x00000000]وفي المخرج أعلاه لاحظ التالي:
- دون سقف أخذت العملية الواحدة نواة كاملة: 0.99 من نواة، وهذا 12.4% من الجهاز، لأن الجهاز فيه 8 معالجات منطقية.
- سقف 20% لم يغير شيئاً: بقيت العملية على 12.4%. وهذه أول نقطة يخطئ فيها كثيرون، فالنسبة في
CpuRateمن الجهاز كله، والوثيقة تقول إن الرقم من وقت المعالج للنظام كله ما لم تكن المهمة داخل مهمة أخرى لها سقف. فخيط واحد لا يستطيع أصلاً أن يتجاوز 12.5% على هذا الجهاز، والسقف 20% أعلى منه. - سقف 5% عمل: أخذت العملية 0.43 من نواة، أي 5.3% من الجهاز، وهذا يعني أنها كانت تعمل ثم تتوقف حتى الفترة التالية، كما تصف الوثيقة: عندما تصل المهمة حدها في فترة الجدولة لا يعمل أي خيط فيها حتى الفترة التالية.
- وأربع عمليات مع سقف 20%: دون سقف أخذت الأربع 3.57 نواة، أي 44.7%، ومع السقف نزلت إلى 1.72 نواة، أي 21.5%، وهذا قريب من السقف المطلوب. فالسقف يطبق على مجموع العمليات في المهمة، لا على كل عملية وحدها.
وهذا هو الحل الذي كنا نبحث عنه للمهمة الليلية: ضعها مع كل ما تشغله في مهمة بسقف 20%، فلن تأخذ أكثر من خمس الجهاز مهما شغلت من عمليات، ومهما كانت أولويتها. وإذا أردت ألا تؤذي التطبيق وأن تأخذ ما يتبقى أيضاً، فاجمع السقف مع أولوية BELOW_NORMAL.

حد عدد العمليات وإشعارات المهمة
الحد الثاني الذي نجربه هو ActiveProcessLimit في الهيكل JOBOBJECT_BASIC_LIMIT_INFORMATION، وهو أقصى عدد للعمليات الحية في المهمة في وقت واحد. وربطنا المهمة بمنفذ إكمال I/O Completion Port كما تشرح وثيقة JOBOBJECT_ASSOCIATE_COMPLETION_PORT، فيرسل Windows إلى المنفذ رسالة عند كل حدث مهم في المهمة: عملية جديدة، أو عملية خرجت، أو تجاوز الحد، أو خلو المهمة من العمليات. ثم وضعنا الحد 2 وحاولنا إضافة ثلاث عمليات:
> job.exe limit
job with ActiveProcessLimit = 2
process 1 (pid 26060): assigned
process 2 (pid 40812): assigned
process 3 (pid 4704): AssignProcessToJobObject failed, error 1816; 2 s later its exit code is 0x103 (STILL_ACTIVE: still suspended, outside the job)
process 3: ended by job.exe itself
port: NEW_PROCESS pid 26060 spin.exe
port: NEW_PROCESS pid 45712 conhost.exe
port: NEW_PROCESS pid 40812 spin.exe
port: NEW_PROCESS pid 9460 conhost.exe
port: ACTIVE_PROCESS_LIMIT pid 0
port: EXIT_PROCESS pid 26060 spin.exe
port: EXIT_PROCESS pid 45712 conhost.exe
port: EXIT_PROCESS pid 40812 spin.exe
port: EXIT_PROCESS pid 9460 conhost.exe
port: ACTIVE_PROCESS_ZERO pid 0
accounting: TotalProcesses 4, ActiveProcesses 0, TotalTerminatedProcesses 0وفي المخرج أعلاه لاحظ التالي:
- العملية الثالثة رفضت بالخطأ 1816: وهو
ERROR_NOT_ENOUGH_QUOTAفي قائمة رموز أخطاء النظام، ومعناه «لا توجد حصة كافية لإتمام الأمر». - ولكن المنفذ يقول إن المهمة فيها أربع عمليات: العمليتان اللتان أضفناهما، ومع كل واحدة منهما عملية
conhost.exe. فكل برنامج طرفية يحصل على مضيف طرفية خاص به، حتى لو شغلناه دون نافذة بالعلمCREATE_NO_WINDOW، وهذا المضيف يدخل المهمة تلقائياً لأن من أنشأه داخلها. ولاحظ أن رسالةACTIVE_PROCESS_LIMITوصلت بعد العملية الرابعة، أي أن المحاسبة رأت التجاوز. فإذا حسبت حد العمليات لبرنامج طرفية فاحسب معهconhost.exe. - رسائل الخروج ثم
ACTIVE_PROCESS_ZERO: وهذه الرسالة الأخيرة طريقة نظيفة لتعرف أن المهمة وكل ما شغلته انتهى، بدل أن تنتظر العملية الأولى فقط ثم تكتشف أن أبناءها ما زالوا يعملون.
ثم وضعنا الحد 1 وشغلنا في المهمة نسخة من spin.exe تحاول تشغيل ابن لها، وهذا ما يحدث داخل المهمة الليلية عندما تشغل أداة الضغط أداة أخرى:
job with ActiveProcessLimit = 1, its process tries to start a child:
the job process exit code: 1816 (the error its CreateProcess returned, 0 = success)
port: NEW_PROCESS pid 9416 spin.exe
port: NEW_PROCESS pid 30112 conhost.exe
port: ACTIVE_PROCESS_LIMIT pid 0
port: EXIT_PROCESS pid 9416 spin.exe
port: EXIT_PROCESS pid 30112 conhost.exe
port: ACTIVE_PROCESS_ZERO pid 0فشل CreateProcess داخل المهمة بالخطأ نفسه 1816، وأعاده البرنامج رمزاً لخروجه. وهذا ما يفعله متصفح Chromium بعمليات العرض كما ذكرنا: حد عملية واحدة، فإذا استطاع مهاجم أن ينفذ كوداً داخل عملية العرض فلن يستطيع أن يشغل منها أي برنامج.
ماذا يحدث إذا رفضت المهمة عملية؟
وهنا المشكلة التي قابلتنا أثناء كتابة المختبر. تقول وثيقة AssignProcessToJobObject إن العملية التي يتجاوز ضمها حد العمليات تنهى ويفشل الضم. ولكن النسخة الأولى من البرنامج كانت تطبع رمز خروج العملية الثالثة بعد ثانيتين، فكان 0x103، وهو STILL_ACTIVE، أي أنها لم تنته. وبعد انتهاء المختبر وجدنا في مدير المهام عملية spin.exe معلقة لا تستهلك شيئاً ولا تنتهي، لأننا أنشأناها معلقة ولم نطلقها، ثم أغلقنا مقبضها ونسيناها. والدرس أوسع من هذه التجربة: إذا أنشأت عملية معلقة لتضعها في مهمة، وفشل الضم لأي سبب، فأنت المسؤول عن إنهائها بالدالة TerminateProcess، وإلا بقيت عملية يتيمة في الجهاز حتى إعادة التشغيل. والكود الحالي يفعل ذلك، كما يبين السطر process 3: ended by job.exe itself.
إنهاء الشجرة كلها: KILL_ON_JOB_CLOSE
بقي الجزء الأخير من المشكلة: الأبناء الذين يبقون بعد إنهاء الأب. والتجربة الأخيرة تشغل spin.exe يشغل حفيداً ينام 30 ثانية، مرة دون مهمة ثم ننهي الأب بالدالة TerminateProcess كما يفعل زر End task في مدير المهام، ومرة داخل مهمة بالعلم JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE ثم نغلق مقبض المهمة فقط:
static void killtest(void) {
for (int withjob = 0; withjob < 2; withjob++) {
HANDLE job = NULL;
if (withjob) {
job = CreateJobObjectW(NULL, NULL); JOBOBJECT_EXTENDED_LIMIT_INFORMATION li = {0};
li.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; SetInformationJobObject(job, JobObjectExtendedLimitInformation, &li, sizeof li);
}
PROCESS_INFORMATION pi = start("--tree 30", TRUE); if (job) AssignProcessToJobObject(job, pi.hProcess); ResumeThread(pi.hThread);
DWORD g = 0; for (int i = 0; i < 50 && !g; i++) { Sleep(100); g = child_of(pi.dwProcessId); }
printf("%s: parent spin.exe pid %lu, grandchild spin.exe pid %lu\n", withjob ? "with job (KILL_ON_JOB_CLOSE)" : "without job", pi.dwProcessId, g);
if (withjob) { CloseHandle(job); printf(" closed the only job handle\n"); }
else { TerminateProcess(pi.hProcess, 1); printf(" TerminateProcess on the parent (what End task does to one process)\n"); }
Sleep(500);
printf(" after 500 ms: parent alive %s, grandchild alive %s\n", alive(pi.dwProcessId) ? "YES" : "no", alive(g) ? "YES" : "no");
if (alive(g)) { kill_pid(g); printf(" (the lab ends the orphan itself: alive %s)\n", alive(g) ? "YES" : "no"); }
CloseHandle(pi.hThread); CloseHandle(pi.hProcess);
}
}والمخرج سوف يكون كما يلي:
> job.exe kill
without job: parent spin.exe pid 19980, grandchild spin.exe pid 24956
TerminateProcess on the parent (what End task does to one process)
after 500 ms: parent alive no, grandchild alive YES
(the lab ends the orphan itself: alive no)
with job (KILL_ON_JOB_CLOSE): parent spin.exe pid 33236, grandchild spin.exe pid 47224
closed the only job handle
after 500 ms: parent alive no, grandchild alive no
[exit code 0 = 0x00000000]دون مهمة انتهى الأب وبقي الحفيد حياً، فهو عملية مستقلة لا يربطها بأبيها إلا رقم محفوظ في EPROCESS، وإنهاء الأب لا يعني شيئاً لها، وقد أنهاه البرنامج بنفسه حتى لا يبقى في الجهاز. ومع المهمة انتهى الأب والحفيد معاً خلال 500 ms، دون أن نستدعي TerminateProcess على أي منهما، لأن إغلاق آخر مقبض للمهمة مع هذا العلم يعني: أنه كل ما فيها. والفائدة الكبرى أن هذا يحدث أيضاً إذا سقط البرنامج الأب نفسه، لأن النواة تغلق كل مقابضه عند خروجه بأي طريقة، فلا يبقى في الجهاز أبناء يتامى من أداة سقطت في منتصف عملها. وهذه هي الطريقة التي يستعملها كثير من مديري العمليات وأدوات البناء على Windows، ويقابلها في Linux أن تضع العمليات في مجموعة cgroup واحدة.
ProcessMemoryLimit لكل عملية وJobMemoryLimit للمهمة كلها. وقد جربناها في مقال مدير الذاكرة في هذه المرحلة، حيث فشل حجز الذاكرة عند الحد بدل أن تنهار العملية.أخطاء شائعة Common Mistakes
- رفع أولوية المهمة الثقيلة لتنتهي أسرع: درجة واحدة جعلت الخيط الأعلى يأخذ 99% من المعالج في المختبر، فأنت بذلك تحرم كل ما هو أدنى منها. وإذا أردت أن تنتهي المهمة أسرع فأعطها معالجات أكثر لا أولوية أعلى.
- افتراض أن REALTIME تعمل لأن الدالة نجحت: النواة أعطتنا HIGH بصمت. اقرأ الفئة بعد أن تضبطها، ولا تستعمل REALTIME إلا إذا كنت تعرف كل ما يعمل على الجهاز.
- بناء التوقيت على
Sleep:Sleep(1)انتظر 15.7 ms، وtimeBeginPeriodلم يغير شيئاً لبرنامج بلا نافذة على Windows 11. انتظر الأحداث بالدوال المخصصة لها، واستعمل ساعة الأداء العالي للقياس. - سقف المعالج بنسبة نواة واحدة: النسبة في
CpuRateمن الجهاز كله، و20% على جهاز بثمانية معالجات تعني 1.6 نواة. - إطلاق العملية قبل ضمها إلى المهمة: أنشئها معلقة بالعلم
CREATE_SUSPENDED، ثم ضمها، ثم أطلقها، وإذا فشل الضم فأنهها بنفسك. - نسيان
conhost.exeفي حد العمليات: كل برنامج طرفية جاء ومعه عملية ثانية داخل المهمة. - إنهاء الأب وانتظار أن يموت الأبناء: Windows لا يربط حياة الابن بأبيه، والحل مهمة بالعلم
KILL_ON_JOB_CLOSE. - النسيج من أجل الأداء: تبديله أسرع، ولكنه يوقف الخيط كله عند أي انتظار، ولا يناسب الكود الحديث. استعمل مجمع الخيوط.
- قراءة حقول PEB وTEB غير الموثقة في كود الإنتاج: الإزاحات قد تتغير بين الإصدارات. استعمل الدوال الموثقة مثل
GetCommandLineWوGetCurrentThreadId، فهي تقرأ الهياكل نفسها بأمان.
جدول قرار: أي أداة لأي مشكلة؟
| ما تريده | الأداة | ما رأيناه في المختبر |
|---|---|---|
| ألا تؤذي مهمة خلفية تطبيقك | فئة BELOW_NORMAL_PRIORITY_CLASS أو IDLE | الأعلى بدرجة أخذ 99%، والأدنى يأخذ ما يتبقى فقط |
| سقف ثابت لمجموعة عمليات | مهمة مع JOB_OBJECT_CPU_RATE_CONTROL_HARD_CAP | أربع عمليات نزلت من 44.7% إلى 21.5% بسقف 20% |
| منع برنامج من تشغيل برامج أخرى | مهمة مع ActiveProcessLimit | CreateProcess فشلت بالخطأ 1816 |
| إنهاء أداة وكل ما شغلته | مهمة مع KILL_ON_JOB_CLOSE | الأب والحفيد انتهيا خلال 500 ms |
| معرفة أن كل الأبناء انتهوا | منفذ إكمال مع رسالة ACTIVE_PROCESS_ZERO | الرسالة وصلت بعد خروج آخر عملية |
| عمل متواز داخل البرنامج | مجمع الخيوط Thread Pool | الخيط كلف 0.117 ms مقابل 26.75 ms للعملية |
| عزل جزء غير موثوق | عملية منفصلة، والأفضل داخل مهمة | سقوط العملية لا يسقط أباها |
| انتظار قصير دقيق | الانتظار على حدث، أو طلب الدقة مؤقتاً | Sleep(1) = 15.7 ms، و1.8 ms بعد إلغاء التجاهل |
تدريب عملي Practice
- غير التجربة الرابعة في
04-quantum.ps1بحيث يكون الفرق بين الخيطين 2 بدل 1 (slices 2 0 12 high)، وقارن نوبات الخيط الأدنى. هل تغير شيء في دفعة مكافحة التجويع؟ - عدل الدالة
capفيjob.cلتستعملJOB_OBJECT_CPU_RATE_CONTROL_WEIGHT_BASEDبوزن 1 لمهمة وبوزن 9 لمهمة أخرى، وشغل المهمتين معاً مثبتتين على معالج واحد، ثم قارن الوقت الذي أخذته كل منهما. - شغل
job.exe killوافتح أثناء الثواني الأولى Process Explorer، وابحث عن عمليتيspin.exeبلونهما الخاص بالعمليات داخل المهام، ثم افتح خصائص إحداهما وانظر إلى صفحة Job فيها. وقد شرحنا قراءة هذه الألوان في مقال Process Explorer.
حذف المختبر Cleanup
السكربت الأخير 99-cleanup.ps1 ينهي أي نسخة متبقية من برامج المختبر تعمل من مجلده، ثم يحذف المجلد في %TEMP%، وقد طبع:
runtime folder removed: True
lab processes still running: 0ولم يغير المختبر شيئاً خارج هذا المجلد: لم يكتب في السجل Registry ولم يغير إعداداً في النظام، وقرأ المفتاح Win32PrioritySeparation قراءة فقط، والأولويات والمهام والسقوف كلها تختفي مع العمليات التي طبقت عليها، والـ Container الذي بنى البرامج حذف نفسه عند انتهائه.
الخلاصة Summary
- العملية حاوية والخيط هو ما يجدوله Windows، والنواة تحفظهما في
EPROCESSوETHREAD، وتترك نسخة مما تحتاجه المكتبات في الـ PEB والـ TEB داخل ذاكرة البرنامج، فقراءة رقم العملية كلفت 1.1 ns مقابل 662 ns لاستدعاء النظام. - إنشاء عملية كلف قرابة 230 ضعف إنشاء خيط، فاستعمل العمليات للعزل والخيوط ومجمعها للتوازي.
- الأولوية رقم من 0 إلى 31 من فئة العملية والقيمة النسبية للخيط، والمجدول يعطي دائماً لأعلى خيط جاهز، فدرجة واحدة أعطت 99% من المعالج، ولم ينقذ الأدنى إلا دفعة مكافحة التجويع كل ثانيتين ونصف تقريباً.
- طول الكوانتم يتغير مع ساعة الجهاز، وقسناه 2 ms على جهاز يطلب فيه برنامج آخر ساعة 1 ms، فلا تبن عليه منطقاً.
Sleep(1)انتظر 15.7 ms، وWindows 11 يتجاهل طلب الدقة من برنامج لا نافذة ظاهرة له إلا إذا طلب غير ذلك صراحة.- كائن المهمة هو الأداة الصحيحة للمهمة الليلية: سقف معالج لكل العمليات معاً، وحد لعددها، وإنهاء الشجرة كلها بإغلاق مقبض واحد.
وفي المقال التالي من هذه المرحلة ننتقل إلى الذاكرة: كيف يحجز Windows مساحة العناوين ويخصصها، وما مجموعة العمل Working Set، ومتى يكتب الصفحات إلى ملف Pagefile، ولماذا يرى مدير المهام ذاكرة أقل مما تظن.
سجل التحديثات Changelog
- نوفمبر 2026: كتابة المقال، وتشغيل المختبر على Windows 11 Pro 24H2 (البناء 26100.9711) بمعالج من أربع أنوية وثمانية معالجات منطقية، بـ Windows PowerShell 5.1 ودون صلاحيات المدير، مع برامج الاختبار مبنية بـ MinGW-w64 GCC 14.2.0 في Container من alpine:3.22.