Tagged articles
softirq
19 articles · Page 1 of 1
An intermittent Redis timeout in a Kubernetes pod was traced not to Redis or the network but to uneven soft‑interrupt handling on a single CPU core, caused by irqbalance moving interrupts across NUMA nodes, and resolved by aligning NIC queues, adjusting irqbalance, and reserving CPUs.
KubernetesLinuxNUMA
0 likes · 11 min read

This article explains the complete Linux network packet lifecycle for UDP, detailing how a packet moves from the physical NIC into kernel memory, is processed by drivers, soft‑irqs, the IP and transport layers, and finally traverses the send path back to the NIC, including key functions, queues, and configuration points.
NetworkingUDPkernel
0 likes · 15 min read

This article demonstrates how to write an eBPF program that attaches to Linux soft‑interrupt entry and exit points, records timestamps in eBPF maps, computes handling duration, updates counters and histograms, and exposes the data to user space for performance analysis.
Kernel TracingLinuxPerformance Monitoring
0 likes · 5 min read

Although moving applications from virtual machines to containers simplifies deployment, benchmark tests reveal that containerized workloads can suffer up to 25 % higher response times and 29 % lower QPS, mainly due to added network hops and increased soft‑interrupt processing in the kernel.
CiliumContainerizationnetwork
0 likes · 7 min read

This article explains the fundamentals of Linux interrupt handling, covering hardware and software interrupts, the IRQ processing flow, maskable vs non‑maskable interrupts, and the three deferred execution mechanisms—softirq, tasklet, and workqueue—along with code examples and performance considerations.
Deferred Executioninterruptssoftirq
0 likes · 15 min read

This article explains the fundamentals of Linux interrupt handling, covering the concepts of hardware and software interrupts, the IRQ processing flow, maskable versus non‑maskable interrupts, and the three deferred execution mechanisms—softirq, tasklet, and workqueue—along with code examples and practical considerations.
Deferred ExecutionLinuxinterrupt handling
0 likes · 14 min read

This article details a systematic investigation and multi‑stage optimization of TencentOS network latency, uncovering kernel soft‑interrupt bottlenecks, proposing and upstreaming patches to net_rx_action, RPS handling, and ksoftirqd scheduling, ultimately reducing handshake failures by over 80% while sharing practical insights for Linux kernel developers.
Linux kernelTencentOSksoftirqd
0 likes · 15 min read

A detailed post‑mortem explains how excessive cgroup files, kubelet's sys‑CPU usage, soft‑interrupt scheduling delays, and a buggy page‑free routine caused intermittent hundreds‑of‑milliseconds network latency in an Alibaba Cloud ACK cluster, and how targeted CPU binding and kernel patches resolved the issue.
Kubernetescgroupcloud-native
0 likes · 14 min read

This article explains the Linux kernel’s packet‑receiving workflow, the role of hardware and soft interrupts, how ksoftirqd processes deferred work, includes key code excerpts, and shows how to monitor softirqs to diagnose performance issues.
Linuxksoftirqdperformance
0 likes · 11 min read

This article explains the fundamentals of Linux interrupt handling, covering the distinction between hardware and software interrupts, the processing flow of hard IRQs, maskable versus non‑maskable interrupts, the need for deferred execution, and a deep dive into softirqs, tasklets, and workqueues with code examples and performance considerations.
Deferred ExecutionLinuxTasklet
0 likes · 15 min read

This article explains the fundamentals of Linux interrupt handling, covering hardware and software interrupt types, the IRQ processing flow, maskable versus non‑maskable interrupts, the need for deferred execution, and detailed mechanisms of softirqs, tasklets, and workqueues with practical code examples.
Deferred ExecutionLinuxinterrupts
0 likes · 14 min read

This article explains the Linux network subsystem architecture, the TCP/IP layering, and the complete path a packet takes from NIC interrupt handling through soft‑irqs, NAPI, and kernel threads to the protocol stack, while also detailing driver registration and send/receive workflows.
Kernel DriversLinuxNAPI
0 likes · 26 min read


ITPUBMay 13, 2021 · Fundamentals
This article provides a deep, step‑by‑step analysis of how Linux 3.10 processes a send() call—from user‑space socket handling through TCP, IP routing, queueing, driver DMA mapping, and both hard and soft interrupt handling—answering why CPU time appears in sy/si, why NET_RX softirqs dominate, and what memory copies occur during transmission.
DMALinuxTCP
0 likes · 32 min read

This comprehensive article provides an in-depth analysis of how Linux kernel sends network packets, covering the complete process from user-space send() call through protocol stack processing to hardware transmission, with detailed source code examination and performance considerations.
DMAPacket TransmissionPerformance Monitoring
0 likes · 28 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


ITPUBAug 21, 2017 · Fundamentals
This article explains Linux interrupt handling mechanisms, covering the basic vector‑table approach, the concept of bottom‑half processing, and the evolution from simple interrupt routines to softirqs, tasklets, and workqueues, while offering practical guidance on when to use each technique.
TaskletWorkqueueinterrupts
0 likes · 8 min read


ITPUBOct 20, 2016 · Fundamentals
This article explains the distinction between hard IRQ and soft IRQ in the Linux x86 32‑bit kernel, detailing how preempt_count tracks interrupt context, how do_IRQ, irq_enter, and irq_exit manage the transition, and how __do_softirq processes pending softirqs with code examples and diagrams.
HardIRQPreemptCountTasklet
0 likes · 9 min read

This article explains Linux kernel interrupt handling in five stages—from acquiring the interrupt number and serializing concurrent interrupts to using softirqs, tasklets, and workqueues for deferred processing—while highlighting the design choices that keep critical code non‑reentrant and the system responsive.
LinuxTaskletWorkqueue
0 likes · 11 min read


ITPUBAug 29, 2016 · Fundamentals
This article explains Linux interrupt handling mechanisms, covering the basic vector‑table approach, the need for bottom‑half processing, and the three main techniques—softirqs, tasklets, and workqueues—while highlighting their advantages, SMP support, and proper usage guidelines.
InterruptSMPTasklet
0 likes · 9 min read
