7a:T402,**Priority**, in the context of CPU scheduling, is a quantitative or qualitative measure that determines the relative urgency with which a process should receive CPU time. This seemingly simple definition conceals layers of complexity that operating system designers must navigate. ### The Semantic Challenge of Priority Before examining mechanisms, we must address a fundamental semantic ambiguity: **what does a priority number actually mean?** Different operating systems adopt diametrically opposite conventions: - **Lower number = Higher priority**: Used in UNIX-like systems (Linux, macOS, BSD). A process with priority 0 is more important than one with priority 10. - **Higher number = Higher priority**: Used in Windows and many real-time operating systems. A thread with priority 31 runs before one with priority 15. This inconsistency has caused countless bugs when developers move between platforms. The conceptual priority (importance) maps to numerical priority differently depending on the operating system.7b:Ta6c,#include #include #include #include #include #include /** * Demonstrates static priority assignment using POSIX real-time scheduling. * Real-time priorities in Linux range from 1 to 99, with 99 being highest. * Requires CAP_SYS_NICE capability or root privileges. */ void* high_priority_task(void* arg) { printf("High priority task executing (priority 80) "); // Critical real-time work here volatile long sum = 0; for (long i = 0; i < 100000000; i++) { sum += i; } printf("High priority task completed "); return NULL; } void* low_priority_task(void* arg) { printf("Low priority task executing (priority 20) "); // Less critical work here volatile long sum = 0; for (long i = 0; i < 100000000; i++) { sum += i; } printf("Low priority task completed "); return NULL; } int main() { pthread_t high_thread, low_thread; pthread_attr_t high_attr, low_attr; struct sched_param high_param, low_param; // Initialize thread attributes pthread_attr_init(&high_attr); pthread_attr_init(&low_attr); // Set scheduling policy to SCHED_FIFO (real-time, static priority) pthread_attr_setschedpolicy(&high_attr, SCHED_FIFO); pthread_attr_setschedpolicy(&low_attr, SCHED_FIFO); // Enable explicit scheduling (don't inherit from parent) pthread_attr_setinheritsched(&high_attr, PTHREAD_EXPLICIT_SCHED); pthread_attr_setinheritsched(&low_attr, PTHREAD_EXPLICIT_SCHED); // Assign static priorities high_param.sched_priority = 80; // High priority (1-99 range) low_param.sched_priority = 20; // Low priority pthread_attr_setschedparam(&high_attr, &high_param); pthread_attr_setschedparam(&low_attr, &low_param); // Create threads with static priorities // Note: Low priority thread created first, but high priority runs first if (pthread_create(&low_thread, &low_attr, low_priority_task, NULL) != 0) { perror("Failed to create low priority thread"); fprintf(stderr, "Error: %s ", strerror(errno)); fprintf(stderr, "Hint: Run with sudo or set CAP_SYS_NICE "); exit(1); } if (pthread_create(&high_thread, &high_attr, high_priority_task, NULL) != 0) { perror("Failed to create high priority thread"); exit(1); } // Wait for completion pthread_join(high_thread, NULL); pthread_join(low_thread, NULL); // Clean up pthread_attr_destroy(&high_attr); pthread_attr_destroy(&low_attr); printf("Both tasks completed "); return 0; }7c:T99a,#include #include /** * Demonstrates static priority assignment on Windows. * Windows combines priority class (process-level) with thread priority * to compute the effective "base priority" (0-31 range). */ DWORD WINAPI HighPriorityTask(LPVOID lpParam) { printf("High priority task executing "); volatile LONGLONG sum = 0; for (LONGLONG i = 0; i < 100000000; i++) { sum += i; } printf("High priority task completed "); return 0; } DWORD WINAPI LowPriorityTask(LPVOID lpParam) { printf("Low priority task executing "); volatile LONGLONG sum = 0; for (LONGLONG i = 0; i < 100000000; i++) { sum += i; } printf("Low priority task completed "); return 0; } int main() { HANDLE hHighThread, hLowThread; // Set process priority class to HIGH_PRIORITY_CLASS // Priority classes: IDLE, BELOW_NORMAL, NORMAL, ABOVE_NORMAL, HIGH, REALTIME if (!SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS)) { printf("Failed to set process priority class "); return 1; } // Create threads hLowThread = CreateThread( NULL, // Default security attributes 0, // Default stack size LowPriorityTask, // Thread function NULL, // No parameter CREATE_SUSPENDED, // Create suspended to set priority first NULL // Don't need thread ID ); hHighThread = CreateThread( NULL, 0, HighPriorityTask, NULL, CREATE_SUSPENDED, NULL ); if (hLowThread == NULL || hHighThread == NULL) { printf("Failed to create threads "); return 1; } // Set thread priorities (within the process priority class) // Thread priorities: IDLE, LOWEST, BELOW_NORMAL, NORMAL, // ABOVE_NORMAL, HIGHEST, TIME_CRITICAL SetThreadPriority(hHighThread, THREAD_PRIORITY_HIGHEST); SetThreadPriority(hLowThread, THREAD_PRIORITY_LOWEST); // Resume threads ResumeThread(hLowThread); ResumeThread(hHighThread); // Wait for completion HANDLE threads[] = { hHighThread, hLowThread }; WaitForMultipleObjects(2, threads, TRUE, INFINITE); // Clean up CloseHandle(hHighThread); CloseHandle(hLowThread); printf("Both tasks completed "); return 0; }7d:T422,**Dynamic priority** adjusts a process's priority during execution based on various runtime factors. This approach sacrifices predictability for adaptability, allowing the scheduler to respond to changing system conditions and process behaviors. ### The Need for Dynamic Priorities Static priorities, while simple, cannot account for: 1. **Behavioral Changes**: A process may alternate between CPU-intensive and I/O-intensive phases. Optimal priority differs between phases. 2. **System Load Variations**: The 'right' priority for a process depends on what else is running. A background task might safely run at higher priority when the system is idle. 3. **Fairness Requirements**: Without dynamic adjustment, high-priority processes can monopolize the CPU, starving lower-priority work. 4. **Responsiveness Demands**: Interactive processes need priority boosts when users interact with them, even if they previously ran at lower priority. ### Dynamic Priority Computation Dynamic priorities are typically computed as a function of multiple factors:7e:Ta34,Dynamic Priority Computation (General Model) ═══════════════════════════════════════════════════════════════════════ effective_priority(P, t) = base_priority(P) + f(cpu_usage(P, t)) + g(wait_time(P, t)) + h(io_behavior(P, t)) + bonus(P, t) Where: ──────────────────────────────────────────────────────────────────────── • base_priority(P) : Initial priority (may be user-specified) • cpu_usage(P, t) : Recent CPU consumption (typically decreases priority) • wait_time(P, t) : Time spent waiting (may increase priority for fairness) • io_behavior(P, t) : I/O-bound processes often receive priority boosts • bonus(P, t) : Context-dependent adjustments (interactive use, etc.) Linux CFS Example (Simplified Virtual Runtime): ──────────────────────────────────────────────────────────────────────── vruntime(P) = vruntime(P) + (delta_exec * NICE_0_LOAD) / weight(P) Where weight(P) is derived from nice value: weight(nice) = 1024 / (1.25 ^ nice) Process with LOWEST vruntime runs next (most "starved" of CPU time). Windows Priority Boost Example: ──────────────────────────────────────────────────────────────────────── When I/O completes: boosted_priority = base_priority + io_boost (io_boost depends on device type: keyboard > disk > network) Boost decays: After each quantum without blocking: priority = max(priority - 1, base_priority) FreeBSD ULE Scheduler: ──────────────────────────────────────────────────────────────────────── priority = PRI_MIN_TIMESHARE + (recent_cpu_ticks * INVERSE_ESTCPU_WEIGHT) - (interactivity_score * INVERSE_INTERACT_WEIGHT) Interactivity score rewards processes that sleep frequently.7f:Tfab,#!/bin/bash # Demonstrating various external priority mechanisms on Linux # ═══════════════════════════════════════════════════════════════ # Nice Values: Traditional UNIX priority adjustment # ═══════════════════════════════════════════════════════════════ # Start a process with reduced priority (nice value +10) nice -n 10 ./cpu_intensive_job & NICE_PID=$! echo "Started CPU job with nice 10 (PID: $NICE_PID)" # Adjust priority of running process renice +15 -p $NICE_PID echo "Adjusted nice value to 15" # View nice values of all user processes ps -eo pid,ni,comm --sort=-ni | head -20 # ═══════════════════════════════════════════════════════════════ # Real-time Priorities: For time-critical applications # ═══════════════════════════════════════════════════════════════ # Set real-time scheduling policy (requires CAP_SYS_NICE or root) # SCHED_FIFO: First-in, first-out real-time scheduling sudo chrt -f 50 ./realtime_task & RT_PID=$! echo "Started real-time task with priority 50 (PID: $RT_PID)" # View scheduling policy and priority chrt -p $RT_PID # ═══════════════════════════════════════════════════════════════ # Control Groups (cgroups v2): Hierarchical resource control # ═══════════════════════════════════════════════════════════════ # Create a CPU-limited cgroup (requires root, cgroups v2 mounted) CGROUP_PATH="/sys/fs/cgroup/background_tasks" sudo mkdir -p "$CGROUP_PATH" # Set CPU weight (default 100, range 1-10000) # Lower weight = less CPU share relative to other cgroups echo 50 | sudo tee "$CGROUP_PATH/cpu.weight" # Move a process into the cgroup echo $NICE_PID | sudo tee "$CGROUP_PATH/cgroup.procs" echo "Moved PID $NICE_PID to background_tasks cgroup with CPU weight 50" # ═══════════════════════════════════════════════════════════════ # ionice: I/O Priority (separate from CPU priority) # ═══════════════════════════════════════════════════════════════ # Classes: 1=realtime, 2=best-effort, 3=idle # Within best-effort: 0 (highest) to 7 (lowest) ionice -c 3 ./disk_heavy_job & IO_PID=$! echo "Started disk job with idle I/O priority (PID: $IO_PID)" # View I/O priority ionice -p $IO_PID # ═══════════════════════════════════════════════════════════════ # Combined Priority Strategy: Real-world configuration # ═══════════════════════════════════════════════════════════════ # For a background batch job: # - High nice value (low CPU priority) # - Idle I/O class (yields to interactive I/O) # - Restricted to specific CPUs nice -n 19 ionice -c 3 taskset -c 0-1 ./batch_job & BATCH_PID=$! echo "Started batch job with all priority restrictions (PID: $BATCH_PID)" # Monitor the processes echo "" echo "Process priorities:" ps -eo pid,ni,cls,pri,comm | grep -E "PID|cpu_intensive|realtime|disk_heavy|batch"80:T1064,#define _GNU_SOURCE #include #include #include #include #include #include #include /** * Demonstrates Linux priority inspection and modification. * Compile: gcc -o priority_demo linux_priority_inspection.c * Run: ./priority_demo (some operations require root) */ const char* policy_name(int policy) { switch (policy) { case SCHED_OTHER: return "SCHED_OTHER (Normal/CFS)"; case SCHED_FIFO: return "SCHED_FIFO (Real-time FIFO)"; case SCHED_RR: return "SCHED_RR (Real-time Round-Robin)"; case SCHED_BATCH: return "SCHED_BATCH (Batch processing)"; case SCHED_IDLE: return "SCHED_IDLE (Idle priority)"; #ifdef SCHED_DEADLINE case SCHED_DEADLINE: return "SCHED_DEADLINE (EDF)"; #endif default: return "Unknown"; } } void print_priority_info(pid_t pid) { struct sched_param param; int policy; int nice_val; printf(" ═══════════════════════════════════════════════════════════════ "); printf("Priority Information for PID %d ", pid); printf("═══════════════════════════════════════════════════════════════ "); // Get scheduling policy policy = sched_getscheduler(pid); if (policy == -1) { perror("sched_getscheduler failed"); return; } printf("Scheduling Policy: %s ", policy_name(policy)); // Get scheduling parameters (priority for RT policies) if (sched_getparam(pid, ¶m) == -1) { perror("sched_getparam failed"); return; } printf("Scheduler Priority: %d ", param.sched_priority); // Get nice value (relevant for SCHED_OTHER, SCHED_BATCH) errno = 0; nice_val = getpriority(PRIO_PROCESS, pid); if (errno != 0) { perror("getpriority failed"); } else { printf("Nice Value: %d ", nice_val); } // Print valid priority ranges printf(" Valid priority ranges: "); printf(" SCHED_FIFO/%s: %d to %d ", "SCHED_RR", sched_get_priority_min(SCHED_FIFO), sched_get_priority_max(SCHED_FIFO)); printf(" SCHED_OTHER: Nice values -20 to +19 "); } int main(int argc, char *argv[]) { pid_t target_pid; if (argc > 1) { target_pid = atoi(argv[1]); } else { target_pid = getpid(); // Self } // Print current priority info print_priority_info(target_pid); // Demonstrate nice value modification (if examining self) if (target_pid == getpid()) { printf(" ─ Demonstrating priority modifications ─ "); // Increase nice value (lower priority) - always succeeds if (nice(5) == -1 && errno != 0) { perror("nice(5) failed"); } else { printf("After nice(5): Nice value = %d ", getpriority(PRIO_PROCESS, 0)); } // Attempt to decrease nice value (raise priority) // Requires CAP_SYS_NICE or root errno = 0; if (nice(-10) == -1 && errno != 0) { printf("nice(-10) failed: %s ", strerror(errno)); printf("(Requires root or CAP_SYS_NICE to decrease nice value) "); } else { printf("After nice(-10): Nice value = %d ", getpriority(PRIO_PROCESS, 0)); } // Attempt to switch to real-time scheduling struct sched_param rt_param; rt_param.sched_priority = 50; if (sched_setscheduler(0, SCHED_FIFO, &rt_param) == -1) { printf("sched_setscheduler(SCHED_FIFO, 50) failed: %s ", strerror(errno)); printf("(Requires root or CAP_SYS_NICE for real-time scheduling) "); } else { printf("Successfully switched to SCHED_FIFO with priority 50 "); print_priority_info(getpid()); } } return 0; }81:T1cf9,#include #include #include // For MMCSS #pragma comment(lib, "avrt.lib") /** * Demonstrates Windows priority mechanisms including: * - Process priority classes * - Thread priorities * - Priority boosting control * - Multimedia Class Scheduler Service (MMCSS) */ void PrintPriorityInfo(HANDLE hThread, const char* label) { printf(" %s: ", label); printf(" Thread Priority: %d ", GetThreadPriority(hThread)); // Note: GetThreadPriorityBoost returns whether boosting is DISABLED BOOL boostDisabled; if (GetThreadPriorityBoost(hThread, &boostDisabled)) { printf(" Priority Boost: %s ", boostDisabled ? "Disabled" : "Enabled"); } } const char* PriorityClassName(DWORD priorityClass) { switch (priorityClass) { case IDLE_PRIORITY_CLASS: return "IDLE"; case BELOW_NORMAL_PRIORITY_CLASS: return "BELOW_NORMAL"; case NORMAL_PRIORITY_CLASS: return "NORMAL"; case ABOVE_NORMAL_PRIORITY_CLASS: return "ABOVE_NORMAL"; case HIGH_PRIORITY_CLASS: return "HIGH"; case REALTIME_PRIORITY_CLASS: return "REALTIME"; default: return "UNKNOWN"; } } int main() { HANDLE hProcess = GetCurrentProcess(); HANDLE hThread = GetCurrentThread(); printf("═══════════════════════════════════════════════════════════════ "); printf("Windows Priority Demonstration "); printf("═══════════════════════════════════════════════════════════════ "); // ───────────────────────────────────────────────────────────────── // Display current priority settings // ───────────────────────────────────────────────────────────────── DWORD priorityClass = GetPriorityClass(hProcess); printf(" Initial Process Priority Class: %s ", PriorityClassName(priorityClass)); PrintPriorityInfo(hThread, "Initial Thread State"); // ───────────────────────────────────────────────────────────────── // Modify process priority class // ───────────────────────────────────────────────────────────────── printf(" ─ Setting process to ABOVE_NORMAL_PRIORITY_CLASS ─ "); if (!SetPriorityClass(hProcess, ABOVE_NORMAL_PRIORITY_CLASS)) { printf("SetPriorityClass failed: %lu ", GetLastError()); } else { printf("Process Priority Class: %s ", PriorityClassName(GetPriorityClass(hProcess))); PrintPriorityInfo(hThread, "After Process Priority Change"); } // ───────────────────────────────────────────────────────────────── // Modify thread priority within class // ───────────────────────────────────────────────────────────────── printf(" ─ Setting thread to THREAD_PRIORITY_HIGHEST ─ "); if (!SetThreadPriority(hThread, THREAD_PRIORITY_HIGHEST)) { printf("SetThreadPriority failed: %lu ", GetLastError()); } else { PrintPriorityInfo(hThread, "After Thread Priority Change"); } // ───────────────────────────────────────────────────────────────── // Disable priority boosting // ───────────────────────────────────────────────────────────────── printf(" ─ Disabling priority boosting ─ "); if (!SetThreadPriorityBoost(hThread, TRUE)) { // TRUE = disable boost printf("SetThreadPriorityBoost failed: %lu ", GetLastError()); } else { PrintPriorityInfo(hThread, "With Boosting Disabled"); } // ───────────────────────────────────────────────────────────────── // Demonstrate MMCSS for multimedia applications // ───────────────────────────────────────────────────────────────── printf(" ─ Registering with Multimedia Class Scheduler Service ─ "); DWORD taskIndex = 0; HANDLE hTask = AvSetMmThreadCharacteristics(TEXT("Pro Audio"), &taskIndex); if (hTask == NULL) { printf("AvSetMmThreadCharacteristics failed: %lu ", GetLastError()); printf("(This may require the MMCSS service to be running) "); } else { printf("Successfully registered as 'Pro Audio' thread "); printf("Task Index: %lu ", taskIndex); PrintPriorityInfo(hThread, "With MMCSS Registration"); // MMCSS-registered threads can request priority changes if (AvSetMmThreadPriority(hTask, AVRT_PRIORITY_CRITICAL)) { printf("Set MMCSS priority to CRITICAL "); PrintPriorityInfo(hThread, "With MMCSS Critical Priority"); } // Unregister when done AvRevertMmThreadCharacteristics(hTask); printf(" MCSS registration reverted "); } // ───────────────────────────────────────────────────────────────── // Demonstrate real-time priority (requires elevation) // ───────────────────────────────────────────────────────────────── printf(" ─ Attempting REALTIME_PRIORITY_CLASS ─ "); if (!SetPriorityClass(hProcess, REALTIME_PRIORITY_CLASS)) { DWORD error = GetLastError(); printf("SetPriorityClass(REALTIME) failed: %lu ", error); if (error == ERROR_ACCESS_DENIED) { printf("(Requires administrator privileges) "); } } else { printf("Process Priority Class: %s ", PriorityClassName(GetPriorityClass(hProcess))); printf("WARNING: REALTIME_PRIORITY_CLASS can destabilize the system! "); // Immediately step back from realtime SetPriorityClass(hProcess, NORMAL_PRIORITY_CLASS); printf("Reverted to NORMAL_PRIORITY_CLASS "); } return 0; }72:{"json":{"id":"seed_dfd44832d5efe35e233f22e105daf725","slug":"priority-scheduling","category":"Operating Systems","topic":"CPU Scheduling","title":"Priority Scheduling","description":"Master priority-based CPU scheduling algorithms, understanding how operating systems assign and manage process priorities, handle starvation through aging, and implement multi-level priority queuing for optimal system performance.","difficulty":"INTERMEDIATE","estimatedMinutes":90,"pages":[{"id":"seed_5aac9d15127bd193c24e6e86d046ca99","title":"Priority Assignment","order":0,"content":[{"id":"priority-imperative","title":"The Priority Imperative in Modern Computing","content":[{"data":{"content":"In the complex orchestration of modern operating systems, not all processes are created equal. A nuclear power plant's safety monitoring system cannot wait in the same queue as a background file indexer. A real-time video conferencing application demands different treatment than a nightly backup job. The mechanism that enables this differentiation—**priority assignment**—forms the foundation of intelligent CPU scheduling.\n\nPriority assignment is far more than a simple numbering scheme. It represents a sophisticated contract between the operating system and its processes, encoding expectations about urgency, importance, resource requirements, and temporal constraints. Understanding how priorities are assigned, interpreted, and managed is essential for anyone seeking to comprehend how operating systems balance the competing demands of dozens or hundreds of concurrent processes."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand the fundamental principles of priority assignment, including static versus dynamic priorities, internal versus external priority sources, the mathematical foundations of priority calculation, and how different operating systems implement priority schemes. You will be equipped to analyze and predict scheduling behavior based on priority configurations.","variant":"info"},"type":"callout"}]},{"id":"foundations-of-priority","title":"Foundations of Priority in Operating Systems","content":[{"data":{"content":"$7a"},"type":"text"},{"data":{"rows":[["Linux (Nice values)","-20 to +19","Lower = Higher","-20","+19"],["Linux (Real-time)","0 to 99","Higher = Higher","99","0"],["Windows","0 to 31","Higher = Higher","31 (Real-time)","0 (Idle)"],["macOS (Mach)","0 to 127","Lower = Higher","0","127"],["FreeBSD","-20 to +20","Lower = Higher","-20","+20"],["VxWorks (RTOS)","0 to 255","Lower = Higher","0","255"],["FreeRTOS","0 to configMAX_PRIORITIES-1","Higher = Higher","configMAX_PRIORITIES-1","0"]],"caption":"Priority Convention Comparison Across Operating Systems","headers":["Operating System","Priority Range","Convention","Highest Priority Value","Lowest Priority Value"]},"type":"table"},{"data":{"icon":"AlertCircle","title":"Priority Inversion of Semantics","content":"When writing cross-platform code or analyzing system behavior, always verify the priority convention. A priority value of '1' means vastly different things on Linux versus Windows. Documentation that simply states 'set priority to 10' without context is dangerously ambiguous.","variant":"warning"},"type":"callout"},{"data":{"content":"### Priority as a Scheduling Parameter\n\nMathematically, priority functions as a **partial ordering** over the set of ready processes. Given processes P₁, P₂, ..., Pₙ in the ready queue, the scheduler selects process Pᵢ such that:\n\n```\npriority(Pᵢ) ≥ priority(Pⱼ) for all j ≠ i\n```\n\nOr, in systems where lower values indicate higher priority:\n\n```\npriority(Pᵢ) ≤ priority(Pⱼ) for all j ≠ i\n```\n\nThis ordering determines CPU allocation decisions, but the derivation of priority values—how they are assigned and updated—varies dramatically across scheduling implementations."},"type":"text"}],"titleType":"number","titleNumber":1},{"id":"static-priority-assignment","title":"Static Priority Assignment","content":[{"data":{"content":"**Static priority** (also called **fixed priority**) assigns a priority value to a process at creation time, which remains constant throughout the process's lifetime. This approach offers predictability and simplicity but sacrifices adaptability to changing system conditions.\n\n### Characteristics of Static Priority\n\nStatic priority systems exhibit several defining characteristics:\n\n1. **Determinism**: Given initial priority assignments, the scheduling sequence is fully predictable. This property is crucial for real-time systems where timing guarantees must be made.\n\n2. **Simplicity**: No runtime computation is required to update priorities. The scheduler simply compares fixed values.\n\n3. **Stability**: Process behavior cannot influence its scheduling priority. A process cannot 'game' the system by altering its execution patterns.\n\n4. **Potential for Starvation**: Low-priority processes may never execute if higher-priority processes remain runnable indefinitely."},"type":"text"},{"data":{"items":["**Process Type Classification** — System processes receive higher priority than user processes. Kernel threads outrank application threads. Device drivers may occupy intermediate levels.","**User Specification** — Unix `nice` values allow users to voluntarily lower their process priority (or raise it, if privileged). Windows allows priority class specification via `SetPriorityClass()`.","**Application-Defined Priority** — Software architects designate priority levels during design. A web server's request handler might run at higher priority than its logging subsystem.","**Resource Ownership** — Processes holding critical resources (locks, device handles) may receive elevated priority to release those resources quickly.","**Rate Monotonic Assignment** — In real-time systems, processes with shorter periods receive higher priority. This is provably optimal for certain task sets."],"title":{"icon":"Target","text":"Common Static Priority Assignment Strategies","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"fileName":"static_priority_examples.c","languages":[{"code":"$7b","label":"C (POSIX)","value":"c"},{"code":"$7c","label":"C (Windows)","value":"c-windows"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Info","title":"Rate Monotonic Scheduling (RMS)","content":"In real-time systems, Rate Monotonic Scheduling assigns static priorities based on task periods: shorter period → higher priority. Liu and Layland proved (1973) that RMS is optimal among fixed-priority algorithms for independent, periodic tasks on a single processor. If a task set is schedulable by any fixed-priority algorithm, RMS will schedule it.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"dynamic-priority-assignment","title":"Dynamic Priority Assignment","content":[{"data":{"content":"$7d"},"type":"text"},{"data":{"fileName":"dynamic_priority_formula.txt","languages":[{"code":"$7e","label":"Mathematical Model","value":"text"}],"showLineNumbers":false},"type":"code"},{"data":{"items":["**CPU Consumption History** — Processes that have consumed significant CPU time recently see priority reductions. This prevents CPU-bound processes from monopolizing the processor.","**Time Spent Waiting** — Processes waiting in the ready queue may receive priority increases (aging). This prevents indefinite starvation of low-priority processes.","**I/O Behavior Patterns** — I/O-bound processes typically receive priority boosts. They voluntarily yield the CPU while waiting for I/O, so boosting their priority when ready improves overall system throughput.","**Interactive Events** — Keyboard input, mouse clicks, and window focus changes may trigger priority boosts for the associated process, improving perceived responsiveness.","**Real-time Constraints** — Approaching deadlines may increase priority in deadline-aware schedulers. Missing a deadline may decrease priority or trigger rescheduling.","**Resource Contention** — Processes holding locks or other synchronization primitives may receive temporary boosts to release those resources quickly, reducing overall blocking time."],"title":{"icon":"Zap","text":"Factors Influencing Dynamic Priority","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"icon":"Lightbulb","title":"Decay Functions and Temporal Relevance","content":"Dynamic priority systems typically weight recent behavior more heavily than past behavior. Exponential decay functions (e.g., weighted averages with decay factor α) ensure that a process's current priority reflects its recent activity rather than ancient history. A process that was CPU-intensive an hour ago but has been idle for 59 minutes shouldn't be penalized for that past behavior.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"internal-external-priority","title":"Internal vs External Priority Sources","content":[{"data":{"content":"Priority assignment sources can be categorized as **internal** (determined by the operating system based on observable process characteristics) or **external** (specified by users, administrators, or applications). Most modern schedulers blend both sources.\n\n### Internal Priority Factors\n\nInternal factors are computed automatically by the operating system:"},"type":"text"},{"data":{"rows":[["CPU Burst Length","Runtime between I/O operations","Shorter bursts → higher priority","Favor I/O-bound processes for throughput"],["I/O Wait Ratio","Time waiting for I/O / total time","Higher ratio → higher priority","I/O-bound processes release CPU voluntarily"],["Memory Usage","Working set size, page fault rate","Varies by policy","May penalize memory-hungry processes"],["Time in System","Total elapsed time since creation","Longer → higher priority (aging)","Prevent indefinite starvation"],["Sleep Frequency","How often process voluntarily yields","More sleep → higher priority","Reward cooperative behavior"],["Recent CPU Time","CPU seconds in last N milliseconds","More CPU → lower priority","Share CPU fairly among processes"]],"caption":"Internal Priority Factors","headers":["Factor","Measurement","Typical Effect","Rationale"]},"type":"table"},{"data":{"content":"### External Priority Factors\n\nExternal factors come from outside the kernel's observations:"},"type":"text"},{"data":{"rows":[["User-specified Nice Value","User or script","`nice`, `renice` commands","`nice -n 10 ./background_job`"],["Process Priority Class","Application API","System call at creation","`SetPriorityClass()` on Windows"],["Real-time Classification","Administrator/application","Scheduler policy selection","`sched_setscheduler()` with `SCHED_FIFO`"],["Control Group (cgroup) Weights","System administrator","cgroup configuration files","Set cpu.weight in cgroup v2"],["Container/VM Resource Limits","Orchestration system","Container runtime configuration","Kubernetes resource requests/limits"],["Affinity Settings","Application or admin","Processor affinity masks","`taskset` command or `pthread_setaffinity_np()`"]],"caption":"External Priority Factors","headers":["Factor","Source","Mechanism","Example"]},"type":"table"},{"data":{"fileName":"priority_sources.sh","languages":[{"code":"$7f","label":"Shell","value":"bash"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Info","title":"Priority Inheritance from Parent Processes","content":"By default, child processes inherit their parent's base priority. This creates natural priority hierarchies—a low-priority daemon's children remain low priority. However, some system calls allow specifying child priority explicitly, and schedulers may reset priority for certain process types (e.g., setuid programs).","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"priority-in-linux","title":"Priority Assignment in Linux","content":[{"data":{"content":"Linux employs a sophisticated multi-layered priority system that accommodates both traditional time-sharing workloads and real-time requirements. Understanding Linux priorities requires grasping the relationship between nice values, scheduling policies, and the underlying priority numbers.\n\n### The Linux Priority Hierarchy\n\nLinux uses a 140-level priority scale internally:\n\n- **Priorities 0-99**: Reserved for real-time processes (SCHED_FIFO and SCHED_RR)\n- **Priorities 100-139**: For normal processes (SCHED_OTHER/SCHED_NORMAL)\n\nThe mapping is:\n\n```\nReal-time priority 99 → Internal priority 0 (highest)\nReal-time priority 1 → Internal priority 98\nReal-time priority 0 → Internal priority 99\nNice -20 → Internal priority 100\nNice 0 → Internal priority 120\nNice +19 → Internal priority 139 (lowest)\n```"},"type":"text"},{"data":{"height":"450px","mermaidSyntax":"graph TB\n subgraph \"Linux Priority Space (140 levels)\"\n subgraph \"Real-Time Range (0-99)\"\n RT99[\"Priority 0\nRT Priority 99\nSCHED_FIFO/RR\"]\n RT50[\"Priority 49\nRT Priority 50\"]\n RT1[\"Priority 98\nRT Priority 1\"]\n RT0[\"Priority 99\nRT Priority 0\"]\n end\n \n subgraph \"Normal/CFS Range (100-139)\"\n NICE_NEG[\"Priority 100\nNice -20\nHighest Normal\"]\n NICE_0[\"Priority 120\nNice 0\nDefault\"]\n NICE_POS[\"Priority 139\nNice +19\nLowest\"]\n end\n end\n \n RT99 --> RT50\n RT50 --> RT1\n RT1 --> RT0\n RT0 -.-> NICE_NEG\n NICE_NEG --> NICE_0\n NICE_0 --> NICE_POS\n \n style RT99 fill:#ff6b6b,color:#fff\n style RT50 fill:#ff8e8e,color:#fff\n style RT1 fill:#ffb3b3,color:#fff\n style RT0 fill:#ffd6d6,color:#333\n style NICE_NEG fill:#4ecdc4,color:#fff\n style NICE_0 fill:#95e1d3,color:#333\n style NICE_POS fill:#d4f1ed,color:#333"},"type":"mermaid-excalidraw"},{"data":{"content":"### Scheduling Policies and Their Priority Semantics\n\nLinux supports multiple scheduling policies, each with different priority interpretations:"},"type":"text"},{"data":{"rows":[["SCHED_FIFO","Real-time","1-99","Runs until blocks or yields; no time slicing","Hard real-time, latency-critical"],["SCHED_RR","Real-time","1-99","Round-robin among same-priority RT processes","Real-time with fairness among equals"],["SCHED_DEADLINE","Real-time","Implicit (deadlines)","Earliest Deadline First (EDF)","Multimedia, periodic tasks"],["SCHED_OTHER","Normal","Nice -20 to +19","CFS with virtual runtime","General-purpose, default"],["SCHED_BATCH","Normal","Nice -20 to +19","CFS optimized for throughput","Batch processing, compilers"],["SCHED_IDLE","Normal","N/A (lowest)","Only runs when CPU idle","Background maintenance"]],"caption":"Linux Scheduling Policies","headers":["Policy","Type","Priority Range","Behavior","Use Case"]},"type":"table"},{"data":{"fileName":"linux_priority_inspection.c","languages":[{"code":"$80","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"AlertCircle","title":"Real-Time Priority Dangers","content":"A runaway SCHED_FIFO process at high priority can render a system unresponsive since it will never yield to lower-priority processes (including the shell). Always have a rescue mechanism: a separate real-time watchdog, SSH access from another machine, or the kernel's RT throttling feature (sched_rt_runtime_us and sched_rt_period_us).","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"priority-in-windows","title":"Priority Assignment in Windows","content":[{"data":{"content":"Windows implements a two-level priority system that separates process-level priority classes from thread-level relative priorities. The combination determines the thread's **base priority**, which the scheduler then dynamically adjusts.\n\n### Priority Classes and Thread Priorities\n\nWindows uses a 0-31 priority range where higher numbers indicate higher priority:\n\n- **Priorities 16-31**: Real-time priority range\n- **Priorities 1-15**: Dynamic priority range (normal applications)\n- **Priority 0**: Reserved for the zero-page thread"},"type":"text"},{"data":{"rows":[["Thread: Time Critical","15","15","15","15","15","31"],["Thread: Highest","6","8","10","12","15","26"],["Thread: Above Normal","5","7","9","11","14","25"],["Thread: Normal","4","6","8","10","13","24"],["Thread: Below Normal","3","5","7","9","12","23"],["Thread: Lowest","2","4","6","8","11","22"],["Thread: Idle","1","1","1","1","1","16"]],"caption":"Windows Base Priority Calculation Matrix","headers":["Process Class →","Idle","Below Normal","Normal","Above Normal","High","Realtime"]},"type":"table"},{"data":{"content":"### Base Priority vs Current Priority\n\nWindows distinguishes between:\n\n- **Base Priority**: Computed from process class and thread priority, remains stable\n- **Current Priority**: Dynamically boosted above base priority based on events\n\nThe current priority can temporarily exceed the base priority but never falls below it. After a boost, priority decays by 1 each quantum until returning to base.\n\n### Priority Boost Triggers\n\nWindows boosts thread priorities in several scenarios:"},"type":"text"},{"data":{"items":["**I/O Completion**: Thread wakes from I/O wait. Boost magnitude depends on device type (keyboard: larger boost; disk: smaller boost).","**Semaphore/Event Release**: Thread unblocked by synchronization primitive receives a boost.","**Foreground Window**: Threads of the foreground application receive increased quantum and potential priority boost.","**GUI Input**: Threads processing mouse or keyboard input receive temporary boosts.","**Priority Inversion Mitigation**: Windows may boost waiting thread priority when it detects a thread holding a needed resource.","**MMCSS (Multimedia Class Scheduler Service)**: Audio/video threads registered with MMCSS receive guaranteed CPU time and elevated priority."],"title":{"icon":"Zap","text":"Windows Priority Boost Events","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"fileName":"windows_priority.cpp","languages":[{"code":"$81","label":"C++ (Windows)","value":"cpp"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Lightbulb","title":"MMCSS for Audio/Video Applications","content":"For multimedia applications requiring guaranteed CPU time, the Multimedia Class Scheduler Service (MMCSS) provides a Windows-native solution. By registering as 'Pro Audio' or 'Playback', threads receive priority boosts and protected time slices. This is preferred over manually setting REALTIME_PRIORITY_CLASS, which can destabilize system-critical services.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"best-practices","title":"Priority Assignment Best Practices","content":[{"data":{"content":"Incorrect priority assignment leads to performance degradation, starvation, priority inversion, and system instability. The following best practices distill decades of operating systems experience into actionable guidelines:"},"type":"text"},{"data":{"items":["**Default to Default Priority** — Unless you have a specific, measurable reason to change priorities, use the system defaults. Priority elevation should be a last resort, not a first instinct.","**Raise Priority Sparingly, Lower Liberally** — It's almost always safe to lower your process's priority (increase nice value). Raising priority risks starving other processes and should require explicit justification.","**Prefer Time Limits to Priority Boosts** — Instead of raising priority to complete work faster, consider whether the work can be structured with reasonable time budgets at default priority.","**Match Priority to Temporal Requirements** — Use high priority only for latency-sensitive work with genuine real-time constraints (audio playback, control systems). Throughput-oriented work (compilation, data processing) rarely needs elevated priority.","**Avoid Priority Starvation by Design** — If using static priorities, ensure lower-priority processes have guaranteed execution windows. Use aging, deadline scheduling, or priority ceiling protocols.","**Consider Priority Inheritance in Lock Design** — When high-priority threads may wait for locks held by low-priority threads, implement priority inheritance to avoid unbounded priority inversion.","**Test Under Contention** — Priority-related bugs often only manifest under heavy system load. Test with realistic workloads that create scheduler pressure.","**Document Priority Decisions** — Priority assignments are often made once and forgotten. Document why specific priorities were chosen so future maintainers understand the constraints."],"title":{"icon":"CheckCircle","text":"Priority Assignment Guidelines","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"left":[{"data":{"icon":"CheckCircle","title":"Do","content":"• Lower priority for batch jobs\n• Use system-provided mechanisms (MMCSS, cgroups)\n• Test priority changes under load\n• Implement priority inheritance for locks\n• Use deadlines instead of static priorities when possible","variant":"success"},"type":"callout"}],"right":[{"data":{"icon":"XCircle","title":"Don't","content":"• Set real-time priority without thorough analysis\n• Assume high priority means faster completion\n• Ignore priority on multi-tenant systems\n• Create priority inversion scenarios\n• Use priority elevation as first solution to performance issues","variant":"error"},"type":"callout"}]},"type":"two-column"}],"titleType":"number","titleNumber":7},{"id":"summary","title":"Summary: Priority Assignment Fundamentals","content":[{"data":{"content":"We have explored the foundational concepts of priority assignment in operating systems. The key takeaways form the basis for understanding the more advanced topics in the remainder of this module:"},"type":"text"},{"data":{"type":"ordered","items":["**Priority semantics vary by OS** — Different operating systems use opposite numerical conventions. Always verify whether higher numbers mean higher or lower priority.","**Static priorities offer predictability** — Fixed priorities, once assigned, never change. This is essential for real-time systems but risks starvation.","**Dynamic priorities offer adaptability** — Priorities that adjust based on runtime behavior improve fairness and responsiveness but sacrifice determinism.","**Priority sources are internal and external** — The OS derives priorities from observed behavior (internal) and from user/application specifications (external).","**Linux uses a 140-level hybrid system** — Combining real-time scheduling policies (0-99) with normal scheduling (nice values mapping to 100-139).","**Windows uses priority class + thread priority** — The combination produces a base priority, which the system dynamically boosts based on events.","**Priority assignment requires discipline** — Elevating priority should be a last resort with documented justification. Default priorities are usually correct."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's Next:**\n\nNow that we understand how priorities are assigned, we'll examine how the scheduler uses these priorities to make scheduling decisions. The next page explores **preemptive versus non-preemptive priority scheduling**—understanding when a higher-priority process can interrupt a running lower-priority process, and the implications of each approach for system behavior."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand the fundamental mechanisms of priority assignment in operating systems, including static vs dynamic priorities, internal vs external sources, and the specific implementations in Linux and Windows. You are prepared to analyze how these priorities influence scheduling decisions.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":8}],"isLocked":false},{"id":"seed_b4e6676da9ecd674aab0ec10dbc61850","title":"Preemptive vs Non-Preemptive Priority Scheduling","order":1,"content":null,"isLocked":true},{"id":"seed_7cf9c2e19b6bf65dec67338c4e0e1876","title":"The Starvation Problem","order":2,"content":null,"isLocked":true},{"id":"seed_879d6cba0cf0f7d6a4cfbbbfee49363a","title":"The Aging Solution","order":3,"content":null,"isLocked":true},{"id":"seed_30fedf1a791f121b9bc24db117305eec","title":"Multiple Priority Levels","order":4,"content":null,"isLocked":true}]}}