This article breaks down the fundamentals of process context switching, explaining CPU registers, program counters, the three-step switch routine, trigger conditions, performance impact, monitoring tools, and practical optimization techniques to help interview candidates answer confidently.
This guide walks readers through the fundamentals of the Linux kernel, explaining its core subsystems, source tree layout, process management, memory handling, file systems, networking, device drivers, debugging tools, and practical learning resources, while providing code examples and command‑line utilities for hands‑on exploration.
The article explains that operating systems act as resource allocators, isolators, and abstraction layers, enabling multiple programs to share limited CPU, memory, and disk resources safely and efficiently through scheduling, memory partitioning, and hiding hardware complexities.
This comprehensive guide explains Linux’s Completely Fair Scheduler (CFS), covering its core principles, virtual runtime calculations, red‑black tree implementation, multi‑core load balancing, real‑time priority handling, and practical tuning techniques with full C++ examples to help developers and sysadmins optimize CPU allocation and system responsiveness.
This article explains Linux process states, how the kernel linked list works, commands for inspecting processes, the nature of zombie and orphan processes, priority handling, context switching, and the O(1) scheduler in the 2.6 kernel, providing a comprehensive overview for system developers.
This comprehensive guide explains Linux process scheduling fundamentals, covering process states, core algorithms such as Round‑Robin, Priority, CFS, Multilevel Feedback Queue, and real‑time policies, while detailing timing triggers, influencing factors, and practical optimization techniques for databases and games.
The article recounts a 1960s IBM system engineer’s struggle with process scheduling, tracing the evolution from simple First‑Come‑First‑Served queues through cooperative multitasking with a yield() call, to timer‑driven preemptive round‑robin and priority‑based algorithms, highlighting each method’s strengths and pitfalls.
The article traces the development of operating‑system process scheduling—from the naïve first‑come‑first‑served approach, through cooperative multitasking with a yield() system call, to timer‑driven preemptive round‑robin and priority schemes—highlighting each method’s strengths and shortcomings.
This article explains Linux process states, how the kernel manages them with linked lists and queues, details commands for inspecting states, discusses zombie and orphan processes, and covers priority concepts and the O(1) scheduler algorithm in depth.
This article provides a comprehensive overview of the Linux process scheduler, explaining why scheduling is needed, how it works, the various scheduling policies such as real‑time and CFS, the mechanisms for priority and load balancing, and the historical evolution of Linux schedulers with code examples.
This article explains the distinction between preemptive and non‑preemptive scheduling and provides a concise overview of common process scheduling algorithms—including FCFS, SJF, HRRN, Round‑Robin, priority and multilevel feedback queue—highlighting their principles, advantages, and drawbacks.
Processes must pause execution to wait for resources, and the Linux kernel provides sleep and wake mechanisms—implemented via functions like schedule_timeout_interruptible and try_to_wake_up—to efficiently relinquish CPU time, avoid busy‑waiting, and resume when resources become ready.
This article explains Linux's process scheduling policies—including real‑time, normal, batch, idle, and deadline—how priorities are assigned, the default CFS scheduler, and practical methods to adjust scheduling and CPU affinity using the chrt command, systemd settings, and cgroup cpuset controls.
Processes represent execution contexts that include code and resources; to avoid wasteful busy‑waiting, operating systems let them sleep and later wake them, using mechanisms like schedule_timeout_interruptible, timers, and try_to_wake_up, which the Linux kernel implements through specific state changes and scheduling logic.
This article explains the Linux kernel architecture, breaks it into three layers and five key subsystems—process scheduling, memory management, virtual file system, network interface, and inter‑process communication—detailing their responsibilities, inter‑dependencies, and providing concrete code examples and diagrams.
This article introduces the core Linux kernel data structures involved in process management and scheduling—task_struct, sched_entity, rq, and sched_avg—explaining their key fields, relationships, and how they enable the kernel to track process state, timing, memory, and load‑balancing decisions.
This article provides a comprehensive technical walkthrough of Linux's sched_ext scheduler extension, explaining how BPF enables custom scheduling policies, detailing the underlying CFS and EEVDF concepts, the new SCHED_EXT class, dispatch queues, kernel configuration, and practical code examples for building and testing BPF‑based schedulers.
This article introduces a new book 'Deep Understanding of Linux Processes and Memory' that systematically explains CPU, memory, and process scheduling principles, covering hardware fundamentals, virtual memory, Golang coroutines, container resource management, and performance optimization techniques.
This comprehensive Q&A explains Linux system composition, kernel placement, core subsystems, address translation, paging structures, process concepts, scheduling algorithms, interrupt handling, system calls, synchronization, deadlock avoidance, and the virtual file system, providing a solid foundation for operating‑system fundamentals.
This article explains Linux process scheduling, the difference between TASK_RUNNING, TASK_INTERRUPTIBLE, and TASK_UNINTERRUPTIBLE states, shows code examples for putting a process to sleep and waking it, analyzes the invalid wakeup race condition, and presents kernel patterns that safely avoid such issues.
This article explains Linux process states, the difference between runnable, interruptible and uninterruptible sleep, how the scheduler and schedule() function manage sleep and wakeup, demonstrates code examples, and discusses the invalid wakeup problem with strategies to prevent it in kernel development.
This article explains how Linux processes transition between running and sleeping states, the difference between interruptible and uninterruptible sleep, common pitfalls such as invalid wakeups, and best‑practice kernel patterns to avoid race conditions when putting a process to sleep.
The article explains that an operating system acts as a resource allocator, isolates processes to maintain system order, and abstracts hardware complexities, using examples of CPU scheduling, memory management, and networking to illustrate why OSes are essential for modern computing.
This article explains Linux process states, how the scheduler puts processes to sleep and wakes them, describes the problem of invalid wake‑ups caused by race conditions, and provides kernel‑level coding patterns to prevent such issues while illustrating with concrete code examples.
When no runnable processes are available, the kernel switches to an idle loop that repeatedly executes the HLT instruction until an interrupt occurs, after which it resumes normal scheduling by switching from the idle process to a ready task.
This article explains how the Linux kernel scheduler allocates CPU time among user processes in multi‑core environments, covering the main scheduler types—CFS, RT, and Deadline—their algorithms, priority schemes, and practical configuration using ps, nice, and chrt commands.
This comprehensive guide walks through the fundamentals of process scheduling in operating systems, covering scheduling concepts, OS classifications, process types, priority mechanisms, preemptive vs cooperative models, design goals, classic algorithms such as FCFS, SJF, RR, MLFQ, and the evolution of Linux schedulers from O(n) and O(1) to the modern CFS, complete with code excerpts and practical examples.
This article explains why binding a process to a specific CPU improves cache performance, shows how to set CPU affinity on Linux using the sched_setaffinity system call, and walks through the kernel's internal implementation—including run‑queue structures, migrate_task, and __migrate_task—illustrated with code and diagrams.
This article explains Linux's scheduling subsystem in depth, covering process definitions, memory layout, state machines, context switches, priority and timeslice handling, the modular scheduler framework, various scheduler classes such as CFS, real‑time and deadline, group scheduling, signal processing, and the differences between kernel and user threads, providing a comprehensive guide for developers and system engineers.
This article explains the fundamentals of Linux ftrace, details the event‑tracing mechanism and tracepoint macros, shows how to enable and filter events on ARM64 Android devices, and demonstrates a practical workflow for capturing low‑probability scheduling bugs in camera‑related processes.
This article provides a comprehensive overview of process and thread scheduling in operating systems, explaining the role of the scheduler, different scheduling algorithms such as FCFS, SJF, round‑robin, priority, multilevel‑queue and lottery, their classification for batch, interactive and real‑time environments, and the key performance goals like fairness, throughput and response time.
This article explains why a Linux system can show a high load average while CPU utilization remains low, covering the concepts of load, multi‑tasking operating systems, process states, scheduling, and common scenarios that cause I/O‑bound load spikes.
High system load can occur even when CPU usage is low, typically due to many processes waiting for disk I/O; this article explains load concepts, process states, scheduling, and common scenarios such as excessive I/O requests, unindexed MySQL queries, and faulty external storage that cause such bottlenecks.
This article explains how Linux processes transition between running, sleeping, and waking states, describes interruptible and uninterruptible sleep, demonstrates code for putting a process to sleep and waking it, and provides strategies to prevent invalid wake‑up scenarios caused by race conditions.
This article provides a comprehensive overview of Linux fundamentals, covering the kernel architecture, virtual memory management, process scheduling and inter‑process communication, the hierarchical file system and VFS layer, device drivers, networking, shell variants, partitioning, mounting, and essential command‑line tools.
The article explains Android’s process lifecycle and how component states translate into OOM adjustments, LowMemoryKiller levels, scheduling groups, and Linux thread priorities, detailing the mapping of importance levels to oom_score_adj, schedGroup, procState, and cgroup policies, with code examples and a bug case.
The article explains why an Android app’s main thread can be blocked by detailing Linux process versus thread concepts, the Completely Fair Scheduler’s priority and vruntime calculations, real‑time and nice priorities, and how Android uses cgroups and SchedPolicy enums to allocate CPU shares among foreground, background, and system threads.
This article explains how Linux processes transition between running, sleeping, and waking states, describes the two sleep modes (interruptible and uninterruptible), illustrates the problem of invalid wake‑ups with example code, and shows kernel‑level techniques to avoid them safely.
This article explains the Linux kernel's process sleep and wake‑up mechanisms, distinguishes interruptible and uninterruptible states, demonstrates how race conditions cause invalid wakeups, and provides concrete code patterns and kernel examples to avoid such bugs.
This article explains the concepts of nice and priority values in Linux, how they differ, their impact on process scheduling, and compares historic O(1) and modern CFS schedulers, including real‑time scheduling policies, providing practical command examples for administrators.
