Tagged articles
network-stack
35 articles · Page 1 of 1
The article explores the Linux kernel’s most impressive designs—including the CFS scheduler, VFS abstraction, memory management tricks, extensible networking stack, driver framework, signal handling, and container foundations—illustrating how they solve real‑world constraints across diverse platforms.
LinuxVFSdevice drivers
0 likes · 8 min read

The article analyzes the limitations of RTOS—such as weak file‑system support, constrained networking, and lack of process isolation—and explains why complex UI, multimedia, AI, and multi‑process requirements force developers to adopt embedded Linux, often in a hybrid architecture.
AIEmbedded LinuxRTOS
0 likes · 7 min read

The article walks through the Linux packet lifecycle—from the send() system call, through the transport and network layers, to the NIC driver—explaining each step, virtual‑network abstractions, and the essential bandwidth, latency, loss, conntrack, and socket buffer metrics to monitor when problems arise.
LinuxMetricsPerformance Tuning
0 likes · 10 min read

sk_buff is the backbone of Linux’s network stack, handling packet storage, metadata, memory management and protocol‑layer interactions; this article dissects its structure, pointer model, core operations, packet lifecycle, practical code examples, and common pitfalls such as memory shortage, data loss and performance bottlenecks.
kernel networkingmemory managementnetwork-stack
0 likes · 54 min read

This comprehensive tutorial walks through the Linux networking stack—from basic concepts, physical and data‑link layers, and addressing schemes to routing protocols, TCP/UDP transport mechanisms, application‑layer services like DNS and HTTP, and security fundamentals—providing clear explanations, step‑by‑step processes, formulas, and visual diagrams to help readers understand how each layer works and interacts.
LinuxOSI modelRouting
0 likes · 64 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 article explains how subtle misconfigurations in the Linux kernel network protocol stack can cause high latency, walks through the stack’s layered architecture, details TCP/UDP mechanisms, and provides practical troubleshooting steps with tools like ethtool, ss, tcpdump, Wireshark, and bpftrace.
LinuxTCPUDP
0 likes · 40 min read

This article explains how traditional kernel network stacks struggle with high‑concurrency, low‑latency cloud data‑center workloads and introduces Baidu Intelligent Cloud’s Polar solution—Polar‑TCP and Polar‑RDMA—which combine user‑space DPDK drivers, a lightweight TCP stack, and an industrial RPC framework to achieve near‑RDMA performance while preserving compatibility with existing TCP ecosystems.
DPDKPolar TCPRDMA
0 likes · 23 min read

This article explains how traditional kernel network stacks struggle with modern cloud data‑center workloads and introduces Baidu Intelligent Cloud's Polar solution—Polar‑TCP and Polar‑RDMA—which combine user‑space DPDK drivers, a lightweight TCP stack, and an industrial‑grade RPC framework to achieve near‑RDMA performance while preserving ecosystem compatibility.
DPDKRDMAcloud computing
0 likes · 24 min read

This article demystifies the Linux kernel by explaining its core subsystems—process scheduling, memory management, virtual file system, networking, and device drivers—while offering practical learning paths, essential commands, code examples, and curated resources for anyone wanting to master Linux internals.
Kernel ModulesProcess Managementdevice drivers
0 likes · 56 min read

This article walks through every stage a network packet undergoes inside the Linux kernel—from hardware interrupt and driver processing, through the sk_buff structures of the TCP/IP stack, to user‑space delivery—while explaining zero‑copy mechanisms like sendfile, splice, mmap and io_uring, and offering concrete tuning commands for optimal performance.
Linuxkernelnetwork-stack
0 likes · 12 min read

This article explores the Linux kernel’s network stack architecture, detailing each layer from the application’s socket interface through transport, network, and link layers, and explains the complete inbound and outbound data flow with code examples illustrating packet reception, processing, routing, and transmission.
LinuxNetworkingSocket
0 likes · 33 min read

This article explains Linux networking fundamentals, comparing the OSI and TCP/IP models, detailing the Linux network stack architecture, packet encapsulation, reception and transmission processes, and introduces essential commands for monitoring network performance and socket statistics.
LinuxOSI modelifconfig
0 likes · 21 min read

This article explains Linux networking fundamentals, covering the OSI and TCP/IP models, the Linux network stack layers, packet encapsulation, MTU considerations, and practical commands such as ifconfig, ip, netstat, ss, and ping for performance monitoring and troubleshooting.
LinuxOSI modelPerformance Monitoring
0 likes · 23 min read

The article examines the scalability limitations of the Linux kernel TCP/IP stack, comparing its packet‑processing and connection‑setup performance with user‑space stacks such as mTCP and F‑Stack, explains how hash‑table locking and spin‑lock contention cause poor CPS scaling, and argues why user‑space implementations often achieve higher throughput despite their own trade‑offs.
TCPkernelnetwork-stack
0 likes · 16 min read

Linux processes network packets through a layered TCP/IP stack, starting with hardware DMA into a ring buffer, handling interrupts, traversing the network interface, IP, transport, and application layers on receive, and reversing the flow for sending, with detailed steps for each layer and driver interaction.
Linuxnetwork-stackpacket processing
0 likes · 10 min read

This article explains the step‑by‑step process Linux uses to receive and transmit network packets, covering the initialization of the network subsystem, the role of the ring buffer, interrupt handling, and the layered processing through the TCP/IP stack from the NIC up to the application.
Linuxkernelnetwork-stack
0 likes · 9 min read

This article explains the Linux network stack, detailing the TCP/IP model layers and describing in depth how incoming packets travel from the NIC through DMA, interrupt handling, and the kernel's protocol layers to the application, as well as the reverse path for outgoing packets.
LinuxNetworkingnetwork-stack
0 likes · 9 min read

This article explains the step‑by‑step process Linux follows to receive network packets from the NIC, pass them through the kernel’s networking stack, and finally deliver them to applications, as well as the reverse path for sending packets from applications to the network.
LinuxNetworkingnetwork-stack
0 likes · 8 min read

Linux handles network traffic through a layered TCP/IP stack, where incoming packets travel from the NIC’s DMA‑filled ring buffer through interrupt handling, protocol layers, and finally to the application, while outgoing packets follow the reverse path, with each layer adding its own headers and processing.
Linuxkernelnetwork-stack
0 likes · 11 min read

This article presents a detailed guide for optimizing large‑scale Apache Flink streaming jobs on the JD Real‑Time Computing platform, covering TaskManager memory model tuning, network stack configuration, RocksDB state management, checkpoint strategies, and additional performance tips with practical examples and calculations.
Apache FlinkPerformance TuningRocksDB
0 likes · 22 min read

The article explains how the Linux kernel implements the TCP three‑way handshake, detailing server listen queue allocation, client connect port selection and SYN transmission, SYN‑ACK processing, state transitions, request‑socket management, full‑connection queue handling, and the final accept call, plus tuning tips.
Linux kernelTCPaccept
0 likes · 19 min read

The article examines the evolution of Tencent Cloud’s F-Stack—a full user‑space networking framework built on DPDK, FreeBSD, and micro‑threading—detailing its architecture, supported versions, POSIX‑compatible API, real‑world deployments such as HttpDNS and DNSPod, performance gains over kernel stacks, and the roadmap for future enhancements.
DPDKF-StackFreeBSD
0 likes · 17 min read

This article explains the layered architecture of the Linux network subsystem, the TCP/IP model implementation, how hardware and soft interrupts are registered and processed, the role of ksoftirqd and NAPI, and the complete send/receive packet flow from NIC to protocol stack.
LinuxNAPIinterrupt handling
0 likes · 28 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

This article outlines the key features of Windows Server 2022 LTSC—including enhanced security with TPM 2.0 and VBS, default HTTPS/TLS 1.3, SMB AES‑256 encryption, network stack improvements, Hyper‑V virtualization upgrades, and the switch to Chromium Edge as the default browser—while noting Microsoft’s new multi‑year support model.
Edge BrowserHyper-VSMB
0 likes · 5 min read

This article explains the layered architecture of the Linux network stack, maps the TCP/IP model to Linux implementation, and details how hardware and soft interrupts, ksoftirqd threads, and NAPI cooperate with driver initialization to process packet reception and transmission.
Driver DevelopmentLinuxNAPI
0 likes · 23 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


ITPUBFeb 2, 2021 · Fundamentals
This article provides a detailed, step‑by‑step walkthrough of the Linux kernel’s packet‑receiving path, covering NIC DMA, hardware and soft interrupts, ksoftirqd threads, NAPI polling, protocol‑stack registration, IP/UDP processing, and the final recvfrom system call that delivers data to user space.
LinuxPacket ReceptionUDP
0 likes · 29 min read

This article explains how Linux implements the TCP/IP model to encapsulate, transmit, and receive network packets, covering OSI vs TCP/IP layers, the Linux network stack structure, NAPI interrupt mitigation, and the step‑by‑step processing of packets in both directions.
LinuxNAPInetwork-stack
0 likes · 12 min read


ITPUBDec 3, 2020 · Fundamentals
This article walks through the complete Linux kernel path a network packet follows—from the NIC’s DMA and hardware interrupt, through soft‑interrupt handling, NAPI polling, protocol‑stack registration, IP and UDP processing, all the way to the user‑space recvfrom system call—revealing the many hidden steps that make packet reception possible.
Linuxinterruptskernel
0 likes · 28 min read

This article examines Flink’s industrial‑scale network stack, detailing the credit‑based flow control introduced in version 1.5, the refactored task‑IO thread collaboration, and serialization optimizations that together improve throughput and latency for large‑scale stream processing workloads.
Credit-based Flow ControlFlinkbig data
0 likes · 12 min read

This article walks through every step from pressing a key on the keyboard to the browser rendering a web page, covering hardware signaling, kernel interrupt handling, DNS resolution, TCP handshakes, HTTP exchange, and final page display, illustrating how many university‑level concepts intersect in a single URL request.
URL processingcomputer architecturenetwork-stack
0 likes · 10 min read

This article introduces the open‑source Contiki operating system for IoT, detailing its history, core features such as memory management and network stacks, source‑level modules, as well as its advantages, drawbacks, and why its ready‑to‑use development environment remains valuable for embedded developers.
ContikiIoTembedded systems
0 likes · 11 min read
