The article explains the design, core concepts, algorithms, and implementation details of Linux 6.6's default EEVDF scheduler, compares it with the legacy CFS, provides practical commands for inspection and switching, and discusses real‑world scenarios and common pitfalls for developers and interview candidates.
The article walks through the evolution of CPU scheduling from a naïve first‑come‑first‑served queue to priority‑based schemes, explains starvation and time‑slice problems, and shows how tracking each task's actual runtime leads to the Completely Fair Scheduler (CFS) with virtual runtime accounting.
The article walks through the evolution of CPU scheduling—from naïve first‑come‑first‑served queues to priority‑based, time‑slice, and finally the Completely Fair Scheduler—illustrating each approach with code, highlighting pitfalls like starvation, and showing how tracking virtual runtime yields fair and responsive task execution.
The article traces the evolution of Linux CPU scheduling from CFS to the EEVDF algorithm, explains EEVDF’s deadline‑driven allocation with concrete task examples, and details Zang Chunxin’s patch that enables shorter slices and wake‑up preemption to reduce latency.
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.
Google engineer Zecheng Li’s patch series merges the CFS scheduler’s cfs_rq and sched_entity structures and switches to a per‑CPU allocator, cutting LLC miss rates by up to 31% and raising kernel IPC by up to 25% on AMD and Intel platforms, with negligible regression.
This article explains Linux’s Completely Fair Scheduler, its data structures, how weight‑based CPU allocation works for containers via cgroup v1 and v2, and demonstrates the calculation of vruntime and practical examples of resource distribution across services.
This article explains how Kubernetes CPU requests and limits interact with Linux namespaces, cgroups v2, and the Completely Fair Scheduler, showing why limits can cause throttling, increase latency, and mislead monitoring, and offers guidance on when to use or avoid CPU limits.
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.
This article explains Linux process concepts, creation methods like fork, vfork and clone, termination handling, and the inner workings of the Completely Fair Scheduler (CFS), including virtual runtime, red‑black tree organization, priority changes, and wake‑up compensation.
The article examines Linux’s CFS scheduler, explaining why its 4 ms tick (250 Hz) defines task switching intervals, how event‑driven mechanisms like task wake and IRQ updates shape scheduling, and compares PELT and WALT load‑tracking methods, especially under heterogeneous big‑little CPU architectures.
This article explains Linux scheduling strategies, including real‑time and non‑real‑time policies, the CFS and Deadline schedulers, command‑line and systemd methods for setting policies, and techniques for CPU affinity using pinning, NUMA awareness, and cgroup cpuset controls.
This article explains the Linux kernel's CPU load‑balancing mechanism, covering concepts such as CPU load, balancing strategies, scheduling domains, groups, the PELT algorithm, CFS scheduling, trigger points, and practical code examples for both regular and real‑time tasks.
This article explains the Linux Completely Fair Scheduler (CFS), covering its design goals, core concepts such as virtual runtime, weight, red‑black tree management, load‑balancing mechanisms, scheduling policies, and answers common questions about its operation and kernel code.
This article explains Linux's CFS scheduler mechanics, including the impact of priority, virtual runtime, event‑driven scheduling, the differences between PELT and WALT load‑tracking algorithms, and the complexities introduced by big‑LITTLE architectures on task placement, throughput, and latency.
This article explains why many Android threads appear idle despite free CPU cycles, by dissecting Linux's five scheduler classes, the distinction between RT and fair scheduling, the role of virtual runtime and weight, and how cgroup cpu.shares can reshape resource distribution, supported by concrete systrace experiments.
A detailed walkthrough of a friend's first‑round interview at Toutiao, covering self‑introduction, project deep‑dive, OS scheduling, TCP reliability, SQL join, and two linked‑list reversal implementations, with the exact questions and code shown.
The article explains how Linux’s multicore scheduler distributes tasks across CPU cores, describes the core CFS and real‑time algorithms, details load‑balancing mechanisms such as pull/push and active/passive strategies, and discusses power, thermal, and algorithmic optimizations for servers and embedded devices.
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.
The article explains how the Earliest Eligible Virtual Deadline First (EEVDF) scheduler, introduced in Linux 6.6, replaces CFS by using virtual deadlines and a lag concept to achieve both fairness and interactivity, and walks through concrete formulas, parameter settings, and step‑by‑step scheduling examples.
The article explains how Linux's Completely Fair Scheduler (CFS) uses nice values and weight tables to compute virtual runtime, organizes tasks in a red‑black tree, and demonstrates through experiments how SCHED_NORMAL, SCHED_BATCH, and SCHED_IDLE differ in priority, preemption rules, and CPU share.
This article explains how Kubernetes resource requests and limits map to Linux cgroup settings via the CFS scheduler, illustrates the underlying calculations for cpu.shares and cpu.cfs_quota_us, and discusses the impact on programming languages such as Go and Java within containers.
This article explains the concepts, reasons, and implementation details of Linux process scheduling, covering cooperative and preemptive scheduling, run‑queue structures, wake‑up paths, scheduling ticks, context switching, priority handling, and the various scheduling classes used in the kernel.
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.
An in‑depth overview of Linux’s Completely Fair Scheduler (CFS) explains its design goals, data structures such as red‑black trees and virtual runtime, the evolution from O(n) and O(1) schedulers, weight‑based fairness calculations, scheduling classes, and key kernel functions that implement task selection and timing.
The talk from DataFun Summit 2023 explains how Baidu's CFS storage builds a trillion‑file‑scale distributed file system by revisiting file system fundamentals, POSIX limitations, historical storage architectures, and introducing a lock‑free metadata service with single‑shard primitives, data‑layout optimizations, and a simplified client‑centric architecture that achieves high scalability and performance.
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 article explains how introducing a remote cache backed by CFS and Zstandard compression into cloud‑native CI/CD pipelines dramatically reduces build times by 3‑5 times, outlines the implementation steps, tool choices, cache key strategy, eviction policy, and showcases performance gains across Java, Node.js, Go, and GCC builds.
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 the technical details of Linux kernel preemption, covering the difference between preemptible and non‑preemptible kernels, the role of the reschedule flag and preempt count, scheduling checkpoints and preempt points, low‑latency handling in non‑preemptible kernels, and the voluntary preemption model.
This article analyzes the limitations of the Linux Completely Fair Scheduler (CFS) for high‑priority workloads, introduces Tencent's custom offline BT scheduler that provides absolute preemption, and presents experimental results showing significant improvements in latency, CPU utilization, and carbon‑reduction for cloud‑native services.
Learn how Linux selects the next process for CPU execution by exploring key scheduler structures such as task_struct, sched_class, runqueue, the various scheduling policies (CFS, RT, Deadline, etc.), the scheduling flow, and the low‑level context_switch mechanism that swaps address spaces and registers.
This article explains the Linux kernel scheduler's core concepts, walks through the initialization code of the 5.4 kernel (including run queues, scheduling classes, domains, and groups), and details how multi‑core and NUMA topologies are handled to achieve balanced CPU usage.
This article explains Linux's sophisticated scheduling system for multi‑core, SMP, and NUMA architectures, describes global, clustered, partitioned, and arbitrary schedulers, details scheduling domains and load‑balancing mechanisms, and provides practical performance‑tuning techniques using tools like perf, flame graphs, and various kernel optimizations.
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.
The article explains how the Linux CFS scheduler balances load using three mechanisms—periodic balancer on busy CPUs, NOHZ idle balancer that wakes idle CPUs in tickless mode, and the new idle balancer that checks overload and cache state—detailing their triggers, IPI interactions, timing intervals, and key data structures.
This article explains CPU architecture, cache hierarchy, the concept of cache lines, how false sharing degrades performance, mitigation techniques like cache‑line alignment, and the Linux scheduler's task prioritisation, virtual runtime, and run‑queue mechanisms for fair and real‑time execution.
PELT (Per‑Entity Load Tracking) replaces the coarse per‑run‑queue load model in Linux’s CFS scheduler with fine‑grained, decay‑based load and utility measurements for each scheduling entity, enabling more accurate load‑balancing, CPU‑frequency decisions, and hierarchical group scheduling across heterogeneous cores.
During Kuaishou's 2020 Spring Festival red‑envelope campaign, Tencent Cloud's Cloud File Storage (CFS) provided a high‑throughput, read‑heavy NFS solution that handled up to 5 GB/s across 1 700 pods, delivering 100% availability, low latency, and massive interaction volumes for billions of users.
The article analyzes why Windows, macOS, and iOS provide smooth graphical interfaces while Linux and Android feel sluggish, focusing on differences in kernel scheduler design, priority handling, and time‑slice allocation for interactive versus server workloads.
This article surveys the evolution, core concepts, and concrete implementation details of Linux task scheduling, illustrating kernel data structures, scheduling entities, run‑queue management, and the CFS algorithm with code excerpts and explaining how the scheduler balances interactive and background workloads.
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.
