Tagged articles
CPU affinity
29 articles · Page 1 of 1
The article explains why the Linux scheduler’s thread migration hurts deterministic low‑latency trading, outlines three reasons to bind threads to specific cores, demonstrates how to use taskset and Rust’s core_affinity crate for binding, and shows how to verify the binding with htop and command‑line tools.
CPU affinityLinux schedulingPerformance Tuning
0 likes · 13 min read

The article dissects intranode latency in high‑frequency trading systems, tracing the packet journey from the NIC through the kernel, socket and user‑space to the strategy thread, and explains how interrupts, CPU affinity, RSS, Nagle, UDP and kernel‑bypass techniques affect microsecond‑level jitter and tail latency.
CPU affinityNAPITCP_NODELAY
0 likes · 13 min read

This guide shows how to edit nginx.conf to adjust worker_processes based on CPU cores, explains when I/O blocking requires extra workers, and demonstrates Linux‑only worker_cpu_affinity settings with concrete examples for 2, 4, and 8‑core systems, including the exact commands to apply and reload the configuration.
CPU affinityConfigurationNGINX
0 likes · 4 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 affinityCPU schedulingcgroups
0 likes · 36 min read

This article explains why a newly purchased 128‑core AMD EPYC server may perform worse than a 32‑core machine, demonstrates how improper CPU affinity and NUMA configuration cause severe performance loss, and provides step‑by‑step practical methods—including system topology analysis, taskset, numactl, kernel scheduler tweaks, and container settings—to achieve up to 300% improvement.
CPU affinityNUMA
0 likes · 15 min read

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.
CFSCPU affinityLinux
0 likes · 9 min read

The article explains how the Linux kernel decides the CPU for a newly woken task, detailing the roles of wake_affine and select_idle_sibling, the influence of cache topology, run‑queue load, and various idle‑checking heuristics, with concrete examples and code snippets.
CPU affinityLinux kernelTask Scheduling
0 likes · 9 min read

The article analyzes how the Linux kernel decides the CPU for a task that has just been woken, detailing the roles of wake_affine and select_idle_sibling, and examining factors such as cache affinity, idle status, load, and hardware topology that influence the final placement.
CPU affinitykernelselect_idle_sibling
0 likes · 9 min read

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.
CPU affinityLinuxProcess Scheduling
0 likes · 8 min read

This article explains hyper‑threading fundamentals, distinguishes physical, logical, and CPU cores, shows how to query CPU topology on Linux, introduces the concept of CPU affinity, demonstrates using the taskset command and related syscalls, and provides C API examples for setting process and thread affinity.
CPU affinityHyper-ThreadingLinux
0 likes · 14 min read

This guide explains the concepts of Hyper‑Threading, physical vs logical CPUs, how to query CPU information on Linux, and provides detailed instructions for using the taskset command and related programming APIs to set and retrieve CPU affinity for processes and threads.
CPU affinityLinuxMultithreading
0 likes · 12 min read

This guide explains how to edit the nginx.conf file to configure the number of worker processes, determine appropriate values based on CPU cores and workload, and bind workers to specific CPU cores using worker_cpu_affinity, including practical command examples and considerations for blocking I/O.
CPU affinityNGINXServer configuration
0 likes · 4 min read

This article demonstrates how to bind Tokio async tasks to specific CPU cores on Linux using the core_affinity_rs crate, showing code examples for single‑core and multi‑core affinity, performance monitoring on Ubuntu, and step‑by‑step modifications to the Tokio runtime builder.
CPU affinityasynchronousperformance
0 likes · 5 min read

This article explains NUMA architecture, its multithreaded performance overheads such as remote memory access, cache synchronization, context and mode switches, interrupt handling, TLB misses, and memory copies, and then presents optimization techniques like NUMA and CPU affinity, IRQ tuning, and large‑page usage.
CPU affinityLinuxMultithreading
0 likes · 20 min read

This article provides a comprehensive overview of DPDK, detailing its basic and optimization technologies, architectural components such as the Environment Abstraction Layer, core libraries, platform modules, poll‑mode drivers, hugepage memory management, and CPU‑affinity techniques that together enable high‑performance packet processing in NFV and SDN environments.
CPU affinityDPDKnetwork performance
0 likes · 8 min read

This article provides a comprehensive technical overview of DPDK, covering its architecture, core libraries, platform modules, polling and CPU‑affinity techniques, huge‑page memory management, NUMA considerations, OS tuning steps, and integration with OVS for high‑performance packet processing.
CPU affinityDPDKHugePages
0 likes · 18 min read

This article explains DPDK’s open‑source data‑plane framework, detailing its architecture, core libraries, platform modules, poll‑mode drivers, huge‑page memory management, polling technique, and CPU‑affinity strategies that together eliminate kernel bottlenecks and dramatically improve packet‑forwarding performance.
CPU affinityDPDKHugePages
0 likes · 9 min read

This article provides a comprehensive overview of DPDK, covering its fundamental and optimization technologies, software architecture, core libraries, platform modules, poll‑mode drivers, huge‑page usage, polling techniques, and CPU‑affinity strategies for high‑performance packet processing in NFV environments.
CPU affinityDPDKHugePages
0 likes · 9 min read

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.
CPU affinityLinuxProcess Scheduling
0 likes · 9 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 affinityCPU schedulingLinux
0 likes · 20 min read

This article summarizes essential concepts and practical optimization strategies for DPDK, covering architecture fundamentals, x86 performance analysis, virtualization overhead, NFV forwarding bottlenecks, huge‑page usage, polling modes, CPU affinity, and I/O virtualization techniques to achieve high‑throughput, low‑latency packet processing.
CPU affinityDPDKNFV
0 likes · 30 min read

This article explains how MySQL 8.0 Resource Groups enable fine‑grained CPU binding and thread‑priority control, provides sample SQL procedures and commands, details Linux environment setup, discusses implementation internals, outlines known limitations especially in containerized environments, and suggests practical usage scenarios.
CPU affinityMySQLResource Groups
0 likes · 16 min read

This article explores five advanced Java thread techniques—custom thread names, priority management, ThreadLocal storage, user versus daemon threads, and processor affinity—showing how to apply them for better debugging, performance tuning, and reliable concurrent applications.
CPU affinityConcurrencyJava
0 likes · 12 min read

This article presents a detailed case study of intermittent container timeout problems in a Kubernetes environment, examining kernel upgrades, NUMA configurations, CPU affinity bindings, kubelet behavior, cadvisor overhead, and hardware faults, and outlines the investigative steps and solutions applied.
CPU affinityHardware FaultKubernetes
0 likes · 8 min read

This article reviews the historical C10K challenge, explains IO model improvements like epoll, kqueue and IOCP, and details practical Linux performance optimizations such as CPU and memory affinity, RSS/RPS/RFS/XPS, IRQ handling, kernel tuning, and hardware utilization for high‑concurrency servers.
C10KCPU affinityIO Multiplexing
0 likes · 21 min read

The article investigates why massive Redis deployments experience network packet loss despite using 10 Gbps NICs, explains how Linux kernel counters such as net.if.in.dropped are derived from /proc/net/dev, walks through the driver‑to‑kernel processing path, and proposes CPU‑affinity, interrupt‑affinity and NUMA‑aware tuning to eliminate the drops.
CPU affinityLinux kernelNUMA
0 likes · 28 min read


ITPUBJun 20, 2017 · Cloud Computing
This guide explains processor affinity, shows how to isolate host CPUs using the isolcpus kernel parameter, and provides step‑by‑step commands to launch a KVM guest and bind its vCPU threads to dedicated CPUs with taskset, including verification techniques and useful tips.
CPU affinityKVMtaskset
0 likes · 14 min read


ITPUBNov 15, 2016 · Operations
This article shows how to detect a CPU0 load imbalance on a multi‑core web server, confirms PHP‑FPM as the cause with mpstat and pidstat, and provides a Bash script that uses taskset to evenly distribute PHP‑FPM processes across all CPUs, plus a cron tip to keep the setting persistent.
CPU affinityPHP-FPMmpstat
0 likes · 6 min read

This guide explains how to use Gearman for Map/Reduce tasks, assign workers to specific CPU cores with taskset, and configure Nginx worker processes with CPU affinity to fully exploit multi‑core servers and improve overall system efficiency.
CPU affinityGearmanLinux
0 likes · 6 min read
