Tagged articles
CPU Scheduling
51 articles · Page 1 of 1
DeepSeek's DSec infrastructure supports millions of agent sandboxes through layered environments, on-demand image loading via 3FS, memory sharing with virtio-pmem/DAX, CPU scheduling, and trajectory forking, achieving 50x resource overcommit while addressing security challenges like agent-discovered vulnerabilities.
3FSAppArmorCPU Scheduling
0 likes · 12 min read

This article details Linux kernel memory and CPU tuning techniques for high-concurrency systems, covering watermark scaling to avoid direct reclaim storms, dirty page writeback thresholds, swap and overcommit settings, transparent huge page pitfalls, NUMA zone reclaim, CPU governor and IRQ affinity, and Kubernetes CFS quota throttling solutions.
CPU SchedulingKubernetes CFS quotaLinux kernel tuning
0 likes · 35 min read

This comprehensive guide covers seven high-frequency OS interview topics — processes vs threads, IPC mechanisms, thread synchronization, deadlock conditions, virtual memory paging, CPU scheduling algorithms, and zero-copy techniques — with visual diagrams, comparison tables, Java code examples, and production pitfalls to move beyond rote memorization.
CPU SchedulingDeadlockIPC
0 likes · 45 min read

DeepSeek's new paper introduces DSec, a production sandbox infrastructure that manages 300 million daily sandbox instances with 380,000 concurrent at peak, using on-demand image loading, composable layers, memory sharing, and CPU QoS to support large-scale agentic reinforcement learning training.
CPU SchedulingDSecDeepSeek
0 likes · 19 min read

The article uses a cafeteria line analogy to introduce CPU scheduling, then systematically explains FCFS, SJF, Round Robin, priority scheduling, and multilevel feedback queues, highlighting their mechanisms, advantages, drawbacks, and real‑world implementations in Windows, Linux, and macOS/iOS.
CPU SchedulingFCFSMLFQ
0 likes · 8 min read

Honor's MUSCHED introduces a VIP scheduling class between real-time and CFS via eBPF's sched-ext, using scenario-aware thread annotation and cross-process priority propagation to reduce touch-to-display latency by 31% and eliminate 92% of frame drops on 120Hz mobile devices.
AndroidCPU SchedulingMUSCHED
0 likes · 12 min read

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.
CFSCPU SchedulingOperating Systems
0 likes · 10 min read

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.
CFSCPU SchedulingOperating Systems
0 likes · 10 min read

The article explains why modern CPUs, even single‑core ones, can run multiple threads by using short time slices, hyper‑threading hardware, and context‑switch mechanisms, and it discusses the costs, Linux monitoring tools, scheduling strategies, and practical ways to reduce switching overhead.
CPU SchedulingHyper-ThreadingMultithreading
0 likes · 10 min read

This article explains the fundamentals of Linux CPU affinity, compares soft and hard binding, shows how to use taskset, sched_setaffinity, numactl and cgroup cpuset, and provides real‑world case studies for servers, game frameworks, Nginx and Hadoop clusters.
CPU SchedulingCPU affinitycgroups
0 likes · 36 min read

In cloud‑native Kubernetes environments, resource over‑commit and mixed deployments can cause kernel‑level memory reclaim and CPU scheduling delays that manifest as application jitter, and this article explains how to visualize, diagnose, and remediate those delays using the SysOM exporter and related metrics.
CPU SchedulingKubernetesMemory reclaim
0 likes · 13 min read

The article explains how CPU scheduling works, why tasks can overload the processor, outlines common pitfalls such as dead loops, lock contention, memory leaks, priority inversion and context‑switch overload, and provides a step‑by‑step troubleshooting and remediation guide for Linux systems.
CPU SchedulingLinux troubleshootingThread Analysis
0 likes · 17 min read

This guide explains how CPU scheduling works, why 100% CPU usage occurs, and provides a step‑by‑step troubleshooting workflow—including monitoring with top/vmstat, identifying offending threads, analyzing stack traces, and applying both quick‑fix and long‑term remediation techniques—to keep systems stable.
CPU SchedulingLinuxSystem Monitoring
0 likes · 19 min read

This article explains why resource over‑commit in cloud‑native Kubernetes clusters leads to memory and CPU latency, shows how to visualize kernel delays with the ack‑sysom‑monitor exporter, outlines common latency scenarios, and provides step‑by‑step troubleshooting and remediation guidance.
CPU SchedulingCloud NativeKubernetes
0 likes · 11 min read

This article explains how resource oversubscription in cloud‑native Kubernetes environments leads to kernel‑level memory reclaim and CPU scheduling delays, outlines common delay scenarios, demonstrates metric‑driven diagnosis with the ack‑sysom‑monitor exporter, and provides practical solutions to mitigate application jitter.
CPU SchedulingCloud Native MonitoringKubernetes
0 likes · 14 min read

This article explains how Kubernetes uses CPU requests and limits to implement overselling, detailing the underlying Linux cgroup mechanisms, bandwidth throttling, weight‑based scheduling, and practical configuration tips for SREs to balance guaranteed resources with maximum usage.
CPU SchedulingKubernetesResource Limits
0 likes · 16 min read

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.
CFSCPU SchedulingLinux
0 likes · 8 min read

In cloud‑native clusters, resource over‑commit and mixed deployments cause kernel‑level delays such as memory‑reclaim and CPU scheduling latency, which propagate to applications as jitter; this article explains how to visualize, diagnose, and mitigate these issues using the ACK‑SysOM exporter and related monitoring dashboards.
CPU SchedulingMemory reclaimSysOM
0 likes · 9 min read

This article examines the challenges of Energy Aware Scheduling on big‑LITTLE CPUs, detailing how frequency prediction, power calculation, cache hierarchy, out‑of‑order execution, and branch prediction affect task placement decisions, and why the resulting models often remain inaccurate and unreliable.
CPU Schedulingenergy aware schedulingfrequency prediction
0 likes · 14 min read

This article explains how CPU time slices, hyper‑threading, and context‑switching affect multithreaded performance, outlines the costs of thread switches, and offers practical strategies such as lock‑free programming, CAS, reducing thread count, and using coroutines to improve efficiency.
CPU SchedulingHyper-ThreadingJava Concurrency
0 likes · 11 min read

CPU scheduling, a core component of operating systems, determines how processes share CPU resources, and this article explains preemptive vs non‑preemptive scheduling, key evaluation metrics, classic algorithms such as FCFS, SJF, RR, priority, multilevel queues, and guidance on selecting suitable algorithms for various system scenarios.
CPU SchedulingOperating SystemsProcess Management
0 likes · 33 min read

The article explains how modern multi‑core CPUs use time slices, hyper‑threading, and various types of context switches to manage multithreaded workloads, discusses the performance costs of switching, and offers practical optimization strategies such as lock‑free programming, appropriate thread counts, and coroutine usage.
CPU SchedulingHyper-ThreadingJava
0 likes · 9 min read

The author, with over two decades of development experience, argues that many learners treat Linux kernel code as a rote exercise instead of mapping real‑world scheduling problems to code, and outlines essential questions about task_struct management, scheduling policies, CPU placement, fairness, and universal scheduler design.
CPU SchedulingLinux kernelOperating Systems
0 likes · 5 min read

The author, with over two decades of development experience, argues that learning the Linux kernel requires understanding real-world scheduling problems rather than merely copying kernel code, and outlines key questions about task_struct management, priority, preemption, CPU placement, fairness, and universal scheduler design.
CPU SchedulingLinux kerneloperating system fundamentals
0 likes · 4 min read

The article explains how multi‑core CPUs use time slices and hyper‑threading to run multiple threads, describes the mechanics and costs of thread context switching, compares preemptive and cooperative scheduling, and offers practical tips for reducing switching overhead and optimizing thread counts.
CPU SchedulingHyper-Threadingcontext switching
0 likes · 10 min read

The Linux kernel’s extensible scheduler class sched_ext introduces a new ext_sched_class with eBPF‑driven callbacks and dispatch queues, allowing developers to plug custom scheduling policies via struct sched_ext_ops without recompiling the kernel, while integrating into the existing hierarchy and exposing trade‑offs such as central‑CPU load and community adoption challenges.
CPU SchedulingeBPFextensible scheduler
0 likes · 16 min read

This article explains what a vCPU is, how it differs from a physical CPU, the relationship between them, methods for calculating available vCPU counts based on sockets, cores, and threads, and outlines typical allocation, scheduling, and application scenarios in cloud and virtualization environments.
CPU Schedulingresource allocationvCPU
0 likes · 12 min read

This article provides a detailed, code‑driven explanation of how Linux cgroup’s CPU subsystem manages container CPU usage, covering cgroup creation, limit configuration, kernel object relationships, scheduler integration, bandwidth enforcement, and the role of period and slack timers.
CPU SchedulingLinux kernelcfs_bandwidth
0 likes · 27 min read

Thread.Sleep pauses a thread for a specified time, but its behavior depends on OS scheduling; Sleep(0) yields the CPU to let other threads run, while Sleep(1000) doesn’t guarantee immediate wake‑up, illustrating how time‑slice and priority‑based scheduling affect thread execution.
C++CPU SchedulingPreemptive Multitasking
0 likes · 10 min read

This article explains how Koordinator introduces application‑aware QoS classes and flexible CPU binding policies to mitigate the Noisy Neighbor problem in mixed online/offline workloads on Kubernetes clusters, and validates the approach with performance tests on Nginx using wrk.
CPU SchedulingCloud NativeKoordinator
0 likes · 11 min read

StarRocks introduces user‑space scheduling with resource groups and classifiers to provide hard memory isolation, soft CPU/IO isolation, short‑query groups, concurrency limits, and large‑query circuit breaking, balancing isolation and utilization while supporting multi‑tenant workloads and future serverless scenarios.
CPU SchedulingStarRocksmemory hard limit
0 likes · 17 min read

This article explains the fundamentals of CPU scheduling in Linux, covering real-time scheduling for high-priority tasks and the fair scheduling algorithm for user processes, including code examples.
CPU SchedulingCode ExamplesLinux
0 likes · 17 min read

This article explains CPU time slicing, hyper‑threading, and thread context switching, describing how operating systems schedule multiple tasks, the costs of switches, ways to view them on Linux, and practical techniques to reduce overhead and choose optimal thread counts for different workloads.
CPU SchedulingHyper-Threadingthread context switching
0 likes · 10 min read

This article explains how Docker containers rely on Linux cgroups and namespaces for resource isolation, details CPU share and quota scheduling, and shows practical commands to inspect cgroup assignments, helping developers optimize container performance on Kubernetes.
CPU SchedulingDockerKubernetes
0 likes · 16 min read

This article explains how Thread.Sleep works, compares time‑slice and pre‑emptive scheduling, clarifies why Sleep(1000) doesn't guarantee exact wake‑up timing, and shows how Sleep(0) yields the CPU to improve responsiveness in multithreaded applications.
CPU SchedulingConcurrencyMultithreading
0 likes · 10 min read

This article explains the real‑time requirements of industrial control, the limitations of traditional OS kernels, and how Linux RT‑Preempt, Xenomai dual‑kernel, and especially hardware‑assisted RTOS (HW‑RTOS) can dramatically reduce latency, interrupt disable periods, and API execution jitter to achieve hard‑real‑time behavior.
CPU SchedulingEmbeddedRTOS
0 likes · 30 min read

The article explains Linux’s Related Thread Group (RTG) mechanism—its struct definition, default Android grouping, core‑selection logic that boosts whole groups to big‑core clusters, load‑aggregation for DCVS frequency decisions, and the newer busy‑hysteresis feature that delays low‑power entry to improve performance and power efficiency.
CPU SchedulingDCVSLinux kernel
0 likes · 15 min read

The article explains how modern multi‑core CPUs use time slices, hyper‑threading, and various thread scheduling strategies, describes the overhead of context switches, and offers practical optimization techniques to balance thread count and improve concurrency performance.
CPU SchedulingConcurrencyHyper-Threading
0 likes · 11 min read

Thread.Sleep pauses a thread for a specified duration, signaling the OS to exclude it from CPU competition, and Thread.Sleep(0) forces an immediate rescheduling, which can improve UI responsiveness by yielding control to other threads; the article explains these behaviors using time‑slice and preemptive scheduling analogies.
CPU SchedulingConcurrencyOS fundamentals
0 likes · 10 min read

This article explains the purpose and behavior of the Thread.Sleep function in .NET, clarifies common misconceptions about its timing and effects, and relates it to operating‑system scheduling concepts such as time‑slice and preemptive multitasking.
C++CPU Schedulingoperating system
0 likes · 9 min read

iQIYI’s cpu‑share‑syncer daemon runs on every node, reads a pod’s iqiyi.com/cpu‑share annotation, updates the pod’s cpu.shares after disabling the Kubernetes CPU CFS quota, and lets high‑priority video‑production pods pre‑empt CPU from lower‑priority pods, significantly speeding task execution.
CPU SchedulingDaemonSetHigh priority tasks
0 likes · 13 min read

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.
BT schedulerCFSCPU Scheduling
0 likes · 10 min read

This article explains CPU time‑slice scheduling, defines CPU utilization as T2/T1, and demonstrates through C programs how different loops affect measured CPU usage, showing why multi‑core systems can report over‑100% utilization while single‑core systems cannot.
CPU SchedulingCPU utilizationOperating Systems
0 likes · 4 min read

This article explains Linux's sophisticated scheduling system, CPU context switching, and the architecture of hardware and software interrupts, detailing how the kernel manages CPU resources, interrupt contexts, and bottom‑half mechanisms to optimize performance and stability.
CPU SchedulingCPU affinityLinux
0 likes · 20 min read

This article explains the true behavior of Thread.Sleep, clarifies common misconceptions about its timing, compares Thread.Sleep(0) with no sleep, and uses a cake‑sharing analogy to illustrate time‑slice versus preemptive scheduling in operating systems.
C++CPU SchedulingConcurrency
0 likes · 10 min read

This article explains the purpose of Thread.Sleep, clarifies common misconceptions about its timing behavior, compares Unix time‑slice and Windows preemptive scheduling using a cake‑eating analogy, and shows why Thread.Sleep(0) can trigger an immediate CPU‑competition reschedule to improve responsiveness.
CPU SchedulingPreemptive Multitaskingoperating system
0 likes · 10 min read

Thread.Sleep pauses a thread for a specified time, influencing CPU competition; understanding its behavior—including the surprising effects of Sleep(0) and how operating systems schedule threads via time‑slicing or preemptive strategies—reveals why Sleep can affect responsiveness and why it’s used in tight loops.
CPU Schedulingoperating systemthread::sleep
0 likes · 10 min read

This article explains the operating‑system concepts of concurrency and parallelism, illustrates how time‑slicing creates the illusion of simultaneous tasks on a single‑CPU system, defines true parallel execution on multi‑CPU machines, and uses everyday analogies to clarify their differences.
CPU SchedulingConcurrencyOperating Systems
0 likes · 6 min read


DevOpsApr 3, 2016 · Fundamentals
A metaphorical story follows a newly created thread as it learns about extracting request parameters, performing login, handling CPU scheduling, using caches, encountering deadlocks, and ultimately witnessing a system reboot, illustrating core concepts of multithreading, concurrency control, and thread‑pool lifecycle.
CPU SchedulingConcurrencyDeadlock
0 likes · 12 min read

This article outlines how the Linux CPU scheduler manages threads and interrupts, explains context switches, run queue length, CPU utilization metrics, typical performance thresholds, and introduces monitoring tools like vmstat and mpstat, followed by real‑world troubleshooting examples.
CPU SchedulingMonitoring Toolscontext switches
0 likes · 6 min read

This guide explains how Linux manages CPU scheduling fairness and demonstrates three practical methods—nice, cpulimit, and control groups—to prioritize, limit, or allocate CPU resources for processes, complete with compilation steps, command examples, and performance observations using top.
CPU SchedulingLinuxcgroups
0 likes · 10 min read
