7a:T967,#include #include // Setting the current process priority class void SetCurrentProcessPriorityExample() { // Elevate to Above Normal priority BOOL success = SetPriorityClass( GetCurrentProcess(), // Handle to current process ABOVE_NORMAL_PRIORITY_CLASS ); if (success) { std::cout << "Successfully set priority class to Above Normal "; } else { DWORD error = GetLastError(); std::cerr << "Failed to set priority class. Error: " << error << " "; } } // Querying a process's priority class void QueryProcessPriorityExample(HANDLE hProcess) { DWORD priorityClass = GetPriorityClass(hProcess); if (priorityClass == 0) { std::cerr << "Failed to get priority class "; return; } // Decode the priority class const char* className = "Unknown"; switch (priorityClass) { case IDLE_PRIORITY_CLASS: className = "Idle"; break; case BELOW_NORMAL_PRIORITY_CLASS: className = "Below Normal"; break; case NORMAL_PRIORITY_CLASS: className = "Normal"; break; case ABOVE_NORMAL_PRIORITY_CLASS: className = "Above Normal"; break; case HIGH_PRIORITY_CLASS: className = "High"; break; case REALTIME_PRIORITY_CLASS: className = "Realtime"; break; } std::cout << "Process priority class: " << className << " "; } // Starting a new process with a specific priority class void CreateProcessWithPriorityExample() { STARTUPINFO si = { sizeof(si) }; PROCESS_INFORMATION pi; // Create process with Below Normal priority for background work BOOL success = CreateProcess( L"C:\\Path\\To\\BackgroundTask.exe", NULL, // Command line NULL, // Process security attributes NULL, // Thread security attributes FALSE, // Inherit handles BELOW_NORMAL_PRIORITY_CLASS, // Creation flags with priority NULL, // Environment NULL, // Current directory &si, &pi ); if (success) { std::cout << "Background process started with Below Normal priority "; CloseHandle(pi.hProcess); CloseHandle(pi.hThread); } }7b:T642,#include // Demonstrating priority class inheritance behavior void CreateChildWithInheritedPriority() { STARTUPINFO si = { sizeof(si) }; PROCESS_INFORMATION pi; // Parent is running at HIGH_PRIORITY_CLASS // This child will INHERIT High priority (default behavior) CreateProcess( L"child.exe", NULL, NULL, NULL, FALSE, 0, // No flags = inherit parent's priority class NULL, NULL, &si, &pi ); // Child runs at HIGH_PRIORITY_CLASS (inherited) CloseHandle(pi.hProcess); CloseHandle(pi.hThread); } void CreateChildWithExplicitPriority() { STARTUPINFO si = { sizeof(si) }; PROCESS_INFORMATION pi; // Parent is running at HIGH_PRIORITY_CLASS // Explicitly set child to NORMAL (does NOT inherit) CreateProcess( L"child.exe", NULL, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, // Explicit priority class NULL, NULL, &si, &pi ); // Child runs at NORMAL_PRIORITY_CLASS regardless of parent CloseHandle(pi.hProcess); CloseHandle(pi.hThread); } void CreateChildWithDedicatedMode() { STARTUPINFO si = { sizeof(si) }; PROCESS_INFORMATION pi; // CREATE_NEW_CONSOLE creates an independent process // that doesn't share a console but still inherits priority // unless explicitly overridden CreateProcess( L"child.exe", NULL, NULL, NULL, FALSE, CREATE_NEW_CONSOLE | BELOW_NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi ); CloseHandle(pi.hProcess); CloseHandle(pi.hThread); }7c:T488,# Query all processes with priority information Get-Process | Select-Object Name, Id, @{N='Priority';E={$_.PriorityClass}}, @{N='BasePri';E={$_.BasePriority}}, @{N='Handles';E={$_.HandleCount}}, @{N='Threads';E={$_.Threads.Count}} # Find all High priority processes Get-Process | Where-Object { $_.PriorityClass -eq 'High' } | Select-Object Name, Id, PriorityClass # Find all non-Normal priority processes Get-Process | Where-Object { $_.PriorityClass -ne 'Normal' -and $_.PriorityClass -ne $null } | Select-Object Name, PriorityClass | Sort-Object PriorityClass # Change a process priority (requires elevation for some processes) $proc = Get-Process -Name "notepad" $proc.PriorityClass = [System.Diagnostics.ProcessPriorityClass]::BelowNormal # Monitor priority changes using WMI events Register-WmiEvent -Class Win32_ProcessStartTrace -Action { $newProc = Get-Process -Id $event.SourceEventArgs.NewEvent.ProcessID -ErrorAction SilentlyContinue if ($newProc -and $newProc.PriorityClass -ne 'Normal') { Write-Host "Non-standard priority process started: $($newProc.Name) at $($newProc.PriorityClass)" } }72:{"json":{"id":"seed_b30a4a091769e5a1f72310ee9bbaaa87","slug":"windows-scheduling","category":"Operating Systems","topic":"Windows Scheduling","title":"Windows Scheduling","description":"Master the Windows thread scheduling subsystem, from priority classes and levels to priority boosting mechanisms and quantum management. Understand how Windows allocates CPU time and compare its approach with Linux scheduling.","difficulty":"ADVANCED","estimatedMinutes":90,"pages":[{"id":"seed_6ea5985cf45b98a974d5f3c616e4e90b","title":"Priority Classes","order":0,"content":[{"id":"opening-hook","title":"The Foundation of Windows Thread Scheduling","content":[{"data":{"content":"When you launch an application on Windows—whether it's a video game demanding every CPU cycle, a background antivirus scan, or a critical system service—the operating system must decide how to allocate precious processor time among all competing threads. At the heart of this decision lies the **priority class** system, a hierarchical classification that establishes the fundamental importance of each process in the scheduling queue.\n\nUnlike simple round-robin schedulers that treat all tasks equally, Windows employs a sophisticated **priority-driven preemptive scheduler** where threads with higher priorities always run before lower-priority threads. The priority class is the coarse-grained mechanism that places each process into one of six well-defined scheduling tiers, establishing its baseline position in the CPU allocation hierarchy before finer-grained priority levels are applied."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand the complete Windows priority class architecture, including all six priority classes, their intended use cases, how they map to underlying priority ranges, the mechanisms for setting and querying priority classes, and the design rationale that led Microsoft to create this hierarchical scheduling framework.","variant":"info"},"type":"callout"}]},{"id":"windows-scheduling-model","title":"The Windows Scheduling Model","content":[{"data":{"content":"Before diving into priority classes specifically, we must understand the broader Windows scheduling architecture. Windows uses a **priority-based, preemptive scheduling algorithm** with 32 distinct priority levels (0-31). This contrasts sharply with Linux's Completely Fair Scheduler (CFS), which uses a time-based fairness model.\n\n**Key architectural principles:**\n\n1. **Preemption is fundamental**: A higher-priority thread that becomes ready will immediately preempt any lower-priority thread currently running.\n\n2. **Two-tier priority system**: Windows combines **priority classes** (process-level) with **priority levels** (thread-level) to compute a thread's final scheduling priority.\n\n3. **Dynamic priority adjustment**: The scheduler can temporarily boost priorities based on system events, I/O completion, and waiting patterns.\n\n4. **Per-processor ready queues**: Each logical processor maintains its own queue of runnable threads, enabling efficient multiprocessor scheduling."},"type":"text"},{"data":{"icon":"Info","title":"Priority vs. Fairness","content":"Windows' strict priority model prioritizes **responsiveness and predictability** over fairness. A high-priority thread can monopolize the CPU indefinitely if no higher-priority thread exists. This is by design—Windows was built for interactive desktop use where user-facing threads must remain responsive regardless of background load.","variant":"note"},"type":"callout"},{"data":{"content":"**The priority calculation formula:**\n\nEvery thread in Windows has a **base priority** calculated from:\n\n```\nBase Priority = Priority Class Base + Thread Priority Level Offset\n```\n\nThe priority class establishes a *base value* (a number from 1-24 depending on the class), and the thread's priority level adds or subtracts from this base (typically -2 to +2, with special cases going higher). The resulting base priority falls within the 0-31 range.\n\n**Priority ranges:**\n\n- **0**: Reserved for the zero-page thread (system memory management)\n- **1-15**: Dynamic priority range (most user applications)\n- **16-31**: Real-time priority range (critical system threads, specialized applications)"},"type":"text"},{"data":{"rows":[["Priority Class","Process-wide","6 classes (Idle to Realtime)","Application or administrator"],["Priority Level","Per-thread","7 levels (Idle to Time-Critical)","Application code"],["Base Priority","Per-thread","1-31 (computed)","System (from class + level)"],["Current Priority","Per-thread","1-31 (dynamic)","System (after boosts)"]],"caption":"Windows Priority Architecture Overview","headers":["Component","Scope","Values","Set By"]},"type":"table"}],"titleType":"number","titleNumber":1},{"id":"six-priority-classes","title":"The Six Priority Classes","content":[{"data":{"content":"Windows defines six priority classes, each designed for specific categories of workloads. Understanding these classes is essential for designing applications that coexist gracefully with other software on the system.\n\nThe classes, ordered from lowest to highest priority:"},"type":"text"},{"data":{"items":["**IDLE_PRIORITY_CLASS (Base: 4)** — For applications that should only run when no other work is pending. Screen savers, background maintenance tasks, and opportunistic system optimizations use this class.","**BELOW_NORMAL_PRIORITY_CLASS (Base: 6)** — Introduced in Windows 2000 for tasks that are useful but should yield to normal applications. Background file indexing, non-urgent updates, and low-priority batch jobs fit here.","**NORMAL_PRIORITY_CLASS (Base: 8)** — The default for all applications. Most user-launched programs, browser tabs, and productivity applications run at this level.","**ABOVE_NORMAL_PRIORITY_CLASS (Base: 10)** — For applications requiring more CPU access than typical but not critical responsiveness. Compilation tasks, important background processing, and soft-real-time applications may use this class.","**HIGH_PRIORITY_CLASS (Base: 13)** — Reserved for time-critical tasks that must preempt normal applications. Task Manager uses this class so administrators can always regain control of runaway systems.","**REALTIME_PRIORITY_CLASS (Base: 24)** — The highest priority class, giving threads priority 16-31. Reserved for drivers, multimedia timing, and applications where latency is absolutely critical. Misuse can freeze the entire system."],"title":{"icon":"Target","text":"Windows Priority Classes (Low to High)","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"icon":"AlertCircle","title":"The Dangers of Real-Time Priority","content":"The REALTIME_PRIORITY_CLASS is genuinely dangerous. Threads at this level run at priorities 16-31, which can preempt critical system threads including mouse/keyboard input handlers, disk I/O completion threads, and even parts of the kernel. A runaway real-time thread can make the system completely unresponsive, requiring a hard reset. Only use this class with extreme caution and SE_INC_BASE_PRIORITY_NAME privilege.","variant":"warning"},"type":"callout"},{"data":{"rows":[["Idle","0x40","4","Screen savers, background defragmentation, idle-time optimization"],["Below Normal","0x4000","6","Windows Search indexing, non-urgent updates, background sync"],["Normal","0x20","8","All standard applications, browsers, office suites, games"],["Above Normal","0x8000","10","Build systems, active downloads, soft-real-time media"],["High","0x80","13","Task Manager, antivirus real-time scanning, critical services"],["Realtime","0x100","24","Audio/video drivers, hardware control, timing-critical loops"]],"caption":"Priority Class Details","headers":["Priority Class","Constant Value","Base Priority","Typical Use Cases"]},"type":"table"}],"titleType":"number","titleNumber":2},{"id":"setting-querying-priority","title":"Setting and Querying Priority Classes","content":[{"data":{"content":"Windows provides straightforward Win32 API functions for managing priority classes. Applications can set their own priority class (with restrictions for real-time) or query the priority class of other processes.\n\n**Key API functions:**"},"type":"text"},{"data":{"code":"$7a","fileName":"priority_class_api.cpp","showLineNumbers":true},"type":"code"},{"data":{"content":"**Security considerations:**\n\nNot all priority class changes are permitted:\n\n1. **Raising to High**: Requires no special privileges but should be used judiciously. The system won't prevent it, but it can degrade responsiveness for other applications.\n\n2. **Raising to Realtime**: Requires the `SE_INC_BASE_PRIORITY_NAME` privilege. By default, only administrators have this privilege. Attempting to set realtime priority without this privilege will fail with ERROR_ACCESS_DENIED.\n\n3. **Lowering priority**: Any process can lower its own priority class without special privileges.\n\n4. **Modifying other processes**: Requires PROCESS_SET_INFORMATION access right. Protected processes and system processes may deny this access."},"type":"text"},{"data":{"icon":"Lightbulb","title":"Command-Line Priority Control","content":"The 'start' command in cmd.exe accepts priority flags: /LOW, /BELOWNORMAL, /NORMAL, /ABOVENORMAL, /HIGH, /REALTIME. For example: 'start /BELOWNORMAL notepad.exe' launches Notepad at below-normal priority. PowerShell uses Start-Process with -Priority parameter.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"priority-class-inheritance","title":"Priority Class Inheritance","content":[{"data":{"content":"When a process creates a child process, the child's priority class follows specific inheritance rules that developers must understand to avoid unexpected behavior.\n\n**Default inheritance behavior:**\n\nBy default, a child process inherits its parent's priority class. If you launch Notepad from a High priority command prompt, Notepad will also run at High priority. This cascade effect can be problematic:\n\n- A high-priority parent launching many children can overwhelm the system\n- A low-priority maintenance tool's children unexpectedly inherit low priority\n- Priority class spreads through process trees unintentionally"},"type":"text"},{"data":{"code":"$7b","fileName":"priority_inheritance.cpp","showLineNumbers":true},"type":"code"},{"data":{"content":"**Breaking the inheritance chain:**\n\nTo ensure a child process runs at a specific priority regardless of parent:\n\n1. **Explicit priority in CreateProcess**: Pass the desired priority class constant in the creation flags.\n\n2. **Child self-adjusts**: The child process can call `SetPriorityClass` immediately upon startup to reset its own priority.\n\n3. **Job objects**: Place processes in a job object with priority class restrictions.\n\n**Job object restrictions:**\n\nJob objects can enforce priority class limits on all contained processes:"},"type":"text"},{"data":{"code":"#include \n\n// Using job objects to restrict priority classes\n\nHANDLE CreateRestrictedPriorityJob() {\n // Create job object\n HANDLE hJob = CreateJobObject(NULL, L\"RestrictedPriorityJob\");\n if (!hJob) return NULL;\n \n // Set priority class restriction\n JOBOBJECT_BASIC_LIMIT_INFORMATION limits = { 0 };\n limits.LimitFlags = JOB_OBJECT_LIMIT_PRIORITY_CLASS;\n limits.PriorityClass = NORMAL_PRIORITY_CLASS;\n \n SetInformationJobObject(\n hJob,\n JobObjectBasicLimitInformation,\n &limits,\n sizeof(limits)\n );\n \n // Any process assigned to this job cannot exceed Normal priority\n // Attempts to set High or Realtime will be silently capped\n return hJob;\n}\n\nvoid AssignProcessToJob(HANDLE hJob, HANDLE hProcess) {\n AssignProcessToJobObject(hJob, hProcess);\n // Process is now constrained to Normal priority class maximum\n}","fileName":"job_object_priority.cpp","showLineNumbers":true},"type":"code"}],"titleType":"number","titleNumber":4},{"id":"priority-class-practice","title":"Priority Class in Practice","content":[{"data":{"content":"Understanding when and how to use each priority class is essential for building well-behaved Windows applications. Let's examine real-world scenarios and best practices."},"type":"text"},{"data":{"left":[{"data":{"items":["**Default to Normal**: Unless you have a specific reason, leave processes at NORMAL_PRIORITY_CLASS. The system is optimized for this case.","**Use Below Normal for background work**: Indexing, backup, sync operations, and build tasks should yield to interactive applications.","**Idle for truly opportunistic work**: Screen savers and maintenance should use IDLE so users never notice their impact.","**High only for critical responsiveness**: Task Manager, system monitoring, and recovery tools may need High to remain accessible.","**Real-time requires deep expertise**: Only use REALTIME for kernel-adjacent work with guaranteed bounded execution time."],"title":{"icon":"CheckCircle","text":"Best Practices","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"right":[{"data":{"items":["**Elevating 'important' apps to High**: This doesn't make your app faster—it makes everything else slower and can cause system-wide lag.","**Using Realtime for games**: Games should use Normal or Above Normal. Realtime priority can block input processing and freeze systems.","**Ignoring inheritance**: Launcher applications that elevate priority propagate that priority to all launched programs.","**Not testing at Normal**: If your app requires elevated priority to function, the algorithm is broken, not the priority.","**Priority as a performance fix**: Elevating priority doesn't improve throughput—it just moves the bottleneck elsewhere."],"title":{"icon":"XCircle","text":"Common Mistakes","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"accent"},"type":"list"}]},"type":"two-column"},{"data":{"content":"**Case study: Windows Search Indexer**\n\nThe Windows Search service (SearchIndexer.exe) is a masterclass in priority class usage:\n\n1. **BELOW_NORMAL_PRIORITY_CLASS**: The main indexing threads run at Below Normal, ensuring they never interfere with user applications.\n\n2. **I/O Priority Low**: In addition to CPU priority, the indexer sets low I/O priority to minimize disk contention.\n\n3. **Activity detection**: The indexer monitors user activity and backs off when the system is in use.\n\n4. **Power awareness**: On battery, indexing is paused or further throttled.\n\nThis multi-layered approach ensures that even intensive indexing remains invisible to users while still completing its work during idle periods."},"type":"text"},{"data":{"icon":"Lightbulb","title":"I/O Priority Complements CPU Priority","content":"Starting with Windows Vista, I/O operations also have priority levels. A process at Below Normal CPU priority should typically also set Low I/O priority using SetFileInformationByHandle with FileIoPriorityHintInfo. This prevents background processes from saturating the disk and starving foreground applications.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"monitoring-priority-classes","title":"Monitoring and Debugging Priority Classes","content":[{"data":{"content":"Diagnosing priority-related issues requires visibility into the current state of the system. Windows provides several tools for examining priority classes:\n\n**Task Manager:**\n\nThe Details tab in Task Manager shows process base priority. Right-click a process → Set Priority to view or change the priority class. Note that this only affects running processes; the change doesn't persist across restarts.\n\n**Process Explorer:**\n\nSysinternals Process Explorer provides more detailed priority information, including per-thread priorities and real-time priority change notifications. The Properties dialog shows both the base priority and current (boosted) priority.\n\n**PowerShell:**"},"type":"text"},{"data":{"code":"$7c","fileName":"priority_monitoring.ps1","showLineNumbers":true},"type":"code"},{"data":{"content":"**Performance Monitor counters:**\n\nWindows Performance Monitor (perfmon) provides real-time and historical priority-related metrics:\n\n- `Process(*)/Priority Base` — Base priority of each process\n- `Thread(*)/Priority Base` — Base priority per thread\n- `Thread(*)/Priority Current` — Current (potentially boosted) priority\n- `Processor(*)/ % Priority Time` — CPU time at each priority level\n\n**Event Tracing for Windows (ETW):**\n\nFor advanced diagnostics, ETW provides kernel-level visibility into priority changes:"},"type":"text"},{"data":{"code":":: Start kernel trace with thread events\nxperf -on DiagEasy+ThreadPriority\n\n:: Run your scenario here\n\n:: Stop trace and merge\nxperf -d priority_analysis.etl\n\n:: Analyze with Windows Performance Analyzer (WPA)\n:: Open the ETL file and examine the \"Thread Lifetimes\" graph\n:: Priority changes are visible in the thread state timeline","fileName":"etw_priority_tracing.cmd","showLineNumbers":true},"type":"code"}],"titleType":"number","titleNumber":6},{"id":"summary","title":"Summary: Priority Classes Demystified","content":[{"data":{"content":"We've explored the foundational layer of the Windows scheduling architecture. Priority classes establish the coarse-grained scheduling tier for every process in the system, determining the baseline CPU access each application receives."},"type":"text"},{"data":{"type":"ordered","items":["**Windows uses a priority-driven preemptive scheduler** where higher-priority threads always preempt lower-priority threads—responsiveness over fairness.","**Six priority classes** (Idle → Below Normal → Normal → Above Normal → High → Realtime) provide coarse-grained scheduling tiers for processes.","**Base priority = Priority Class Base + Thread Priority Level** — The two-tier system enables both process-level and thread-level priority control.","**Priority classes are inherited by default** — Child processes inherit their parent's priority class unless explicitly overridden.","**Realtime priority is dangerous** — Running at priorities 16-31 can preempt critical system threads and freeze the system entirely.","**I/O priority complements CPU priority** — Well-behaved background applications set both low CPU and low I/O priority.","**Elevated priority ≠ better performance** — Priority affects scheduling order, not throughput. Misusing priority degrades system responsiveness."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's next:**\n\nPriority classes establish the process-level tier, but Windows offers finer-grained control through **priority levels**—per-thread adjustments that allow specific threads within a process to run at higher or lower priorities than the process base. The next page explores these thread priority levels, completing the picture of how Windows computes the final scheduling priority for every thread in the system."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Priority Classes Mastered","content":"You now understand the complete Windows priority class system—the foundation upon which all thread scheduling decisions are built. With this knowledge, you can design applications that are good citizens of the Windows ecosystem, yielding appropriately to other applications while ensuring critical tasks receive the CPU time they require.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":7}],"isLocked":false},{"id":"seed_bb83219fc66c15f0a489fc7e10ddc24e","title":"Priority Levels","order":1,"content":null,"isLocked":true},{"id":"seed_c82bbbb2aa517d827569ad1fa7adee44","title":"Priority Boosting","order":2,"content":null,"isLocked":true},{"id":"seed_63fb9ba75b56d8649fc6a9e183741ccd","title":"Quantum Management","order":3,"content":null,"isLocked":true},{"id":"seed_74a785a6a7b526b6b86342d6746874de","title":"Comparison with Linux","order":4,"content":null,"isLocked":true}]}}