This article explains the challenges of allocating large contiguous physical memory in Linux, introduces the Contiguous Memory Allocator (CMA) as a solution, and provides in‑depth coverage of its design, reservation, migration, data structures, initialization, configuration, usage in drivers, and debugging techniques.
This article presents a comprehensive reliability‑testing workflow for the open‑source Logicanalyzer, covering hardware setup, software requirements, continuous capture stress tests, memory management checks, temperature and power monitoring, performance metrics, troubleshooting, optimization tips, and industrial‑environment validation.
This article explains the fundamentals of zero‑copy, DMA, PageCache and RDMA, compares them with traditional I/O, describes Linux implementations such as sendfile, mmap+write, splice and Java NIO APIs, and shows practical use‑cases that dramatically reduce CPU load and latency in high‑throughput networking and file handling.
The article explains how Direct Memory Access (DMA) eliminates CPU‑bound data copies, compares traditional I/O with zero‑copy techniques such as mmap and sendfile, and shows how reducing system calls and context switches can double file‑transfer throughput while highlighting the limits of kernel cache for large files.
The article explains how batching cache‑sync operations for dma_map_sg, dma_unmap_sg and dma_sync_sg on arm64 can cut their execution time by up to three‑fold, details the kernel patches introduced, and presents benchmark results on Dimensity 9500 and RK3588 platforms.
This article explains why circular buffers are essential for efficient data‑stream handling in embedded systems, introduces the open‑source LwRB library, details its memory‑safe and thread‑safe design using C11 atomics, provides core data structures and example code, and compares ring buffers with normal buffers and message queues.
This article explains the purpose, operation modes, configuration parameters, and register-level setup of DMA in STM32 microcontrollers, illustrating how DMA offloads data transfers from the CPU, improves performance, and provides concrete code examples for UART and memory‑to‑memory transfers.
The article explains how storage media speed, kernel and user mode separation, and context‑switch overhead affect I/O performance, then details DMA, zero‑copy methods such as mmap + write and sendfile, the role of PageCache, and best practices like async and direct I/O for large‑file transfers.
This article explains the performance bottlenecks of traditional I/O, introduces zero‑copy concepts and their relationship with DMA and PageCache, details RDMA architectures, and demonstrates practical zero‑copy implementations such as mmap+write, sendfile, splice, tee, and Java NIO APIs.
This article explains the principles behind zero‑copy, DMA, and RDMA, compares traditional I/O copying with modern zero‑copy techniques, and shows practical implementations in Linux and Java that dramatically reduce CPU overhead and boost network and file‑transfer throughput.
This article explains how the Input/Output Memory Management Unit (IOMMU) protects computers from DMA‑based attacks, details its architecture, DMA and interrupt remapping mechanisms, implementations across Intel, AMD and ARM, and provides practical configuration and programming guidance for secure virtualization and cloud environments.
This article explains several practical techniques for printing debug logs in embedded development—using SRAM buffers, SWO trace, UART with DMA, and GPIO‑bit‑banging—detailing their implementation, advantages, limitations, and code examples for reliable diagnostics on chips lacking conventional serial interfaces.
This article provides a comprehensive interview guide for embedded systems positions, covering Linux thread scheduling, single‑core CPU execution, STM32 chip specifications, SPI communication, DMA concepts, synchronization primitives, priority inversion solutions, debugging techniques, and software design considerations.
This article explains the principles of Direct Memory Access (DMA) and Remote Direct Memory Access (RDMA), compares them with traditional TCP I/O, outlines RDMA’s features, protocol standards, communication pathways, queue mechanisms, and provides example code for setting up RDMA connections using RoCEv2.
This article explains how mmap and zero‑copy mechanisms, combined with DMA and shared‑memory APIs, can dramatically reduce CPU involvement, context switches, and data copies during file and network I/O, thereby improving system performance for high‑throughput applications.
Zero‑copy eliminates CPU‑mediated data copies between user and kernel spaces by using DMA and memory‑mapping, dramatically improving I/O performance, reducing context switches, and enabling high‑throughput applications such as file servers, Kafka brokers, and Java networking frameworks.
This article explains how Linux zero‑copy techniques—DMA, sendfile, splice, mmap + write, and tee—reduce CPU involvement in large file and network transfers by moving data directly within kernel space, detailing their workflows, code examples, performance trade‑offs, and suitable use cases.
This article provides an extensive overview of embedded software fundamentals, covering heap vs. stack differences, wild pointers, DMA roles, inter‑process communication methods, memory allocation strategies, malloc vs. new, volatile usage, pointer concepts, Linux kernel locks, FreeRTOS mechanisms, stack overflow prevention, compilation stages, quick‑sort algorithm, header inclusion, CAN identifiers, struct memory optimization, STM32 interrupt handling, user‑to‑kernel transitions, and condition‑variable thundering‑herd effects.
This article explains DMA fundamentals, compares Block DMA and Scatter‑Gather DMA step by step, and evaluates the open‑source RIFFA PCIe framework, including its hardware flow, software components, board‑level performance tests, features, drawbacks, and licensing terms.
Zero‑copy techniques such as mmap + write, sendfile, and sendfile + DMA scatter/gather reduce CPU‑memory copies and context switches compared with traditional read/write IO, improving performance for high‑throughput systems like RocketMQ and Kafka, while explaining user‑kernel mode, DMA, and their trade‑offs.
Zero‑copy is an optimization technique that eliminates unnecessary memory copies between kernel and user space by leveraging DMA, memory‑mapping and specialized system calls, thereby reducing CPU load, latency and improving throughput for high‑performance networking, storage and multimedia workloads.
This article consolidates DPDK 17.11 source‑code notes to explain the library’s memory‑management subsystem, covering hugepage concepts, shared configuration mapping, NUMA‑aware allocation, and the custom allocator that enables high‑throughput packet processing on Linux.
This comprehensive guide explains Linux memory fundamentals, address space layout, fragmentation, the buddy and slab allocators, kernel and user‑mode memory pools, DMA handling, common programming pitfalls, and practical tools for monitoring memory usage.
This comprehensive guide explores Linux memory architecture, address spaces, allocation strategies like the buddy and slab allocators, user‑ and kernel‑level memory management, DMA, and practical tips to avoid common memory bugs and performance issues.
This article provides a comprehensive guide to Linux memory management, covering memory fundamentals, address spaces, MMU translation, segmentation and paging, the buddy and slab allocation algorithms, kernel and user memory pools, typical usage scenarios, common bugs, and practical tools for monitoring and debugging memory usage.
The article explains what memory semantics means in modern data‑center contexts, compares Infiniband and CXL definitions, clarifies load/store and DMA operations, and highlights the distinction between memory space and memory access with concrete examples and references.
This article explains the principles of Direct Memory Access (DMA), compares it with traditional I/O, details the DMA data‑transfer workflow, and explores zero‑copy techniques such as mmap + write and sendfile, highlighting how they reduce context switches, data copies, and improve overall Linux I/O efficiency.
This article explains Direct Memory Access (DMA), compares it with traditional I/O, details the complete DMA‑based I/O workflow, and explores zero‑copy techniques such as mmap, sendfile, and asynchronous I/O, highlighting their impact on context switches, data copies, and overall transfer performance.
This article explains how the European Union's Digital Markets Act forces Microsoft to provide uninstall options for built‑in apps like Edge, shows where to edit the IntegratedServicesRegionPolicySet.json file to change the disabled flag, and offers a third‑party tool for additional Windows 11 tweaks.
This article explains the traditional I/O read/write workflow, identifies its performance bottlenecks, introduces the concept of zero‑copy, and demonstrates practical zero‑copy implementations—including DMA, sendfile, shared memory, memory‑mapped files, and Java NIO techniques such as ByteBuffer, Channel, transferTo/transferFrom, and memory‑mapped files.
This article provides a comprehensive guide to Linux memory management, covering memory fundamentals, address space layout, paging and segmentation, the buddy and slab allocation algorithms, kernel and user‑space memory pools, common pitfalls, and practical tools for monitoring and debugging memory usage.
This comprehensive guide explores Linux memory fundamentals, address space layout, fragmentation, the buddy and slab allocation algorithms, kernel and user‑space memory usage scenarios, and common pitfalls, providing backend developers with practical insights to improve performance and stability.
This article explains the fundamentals of Direct Memory Access (DMA) and Remote Direct Memory Access (RDMA), compares their data transfer mechanisms with traditional networking, and outlines RDMA's advantages, protocols, ecosystem, and real‑world adoption in high‑performance computing and data centers.
This article explains the principles of DMA and RDMA, compares RDMA protocols such as InfiniBand, RoCE, and iWARP, outlines their performance advantages, and reviews the key standards bodies, open‑source communities, hardware vendors, and real‑world adoption in high‑performance data centers.
This article explains how storage media performance, kernel‑user mode transitions, DMA, zero‑copy, and PageCache interact to affect I/O latency, why multiple data copies and context switches hurt throughput, and how techniques like mmap, sendfile, and asynchronous I/O can reduce overhead.
This article explains why Linux’s native networking stack falls short of line‑speed, analyzes the core latency sources such as DMA, memory copying, routing look‑ups and lock contention, and proposes a comprehensive set of kernel‑level redesigns—including VOQ queues, lock‑free data structures, and user‑space stacks—to achieve near‑wire‑speed forwarding.
This article explains the performance hierarchy of storage media, the distinction between kernel and user modes, how data moves between them, and why excessive context switches hurt I/O, then introduces DMA, zero‑copy, PageCache, mmap + write, sendfile, and tuning tips to dramatically improve Linux I/O efficiency.
The article explains how different storage media affect I/O speed, describes kernel and user mode separation, introduces DMA and zero‑copy techniques such as mmap + write and sendfile, and discusses PageCache behavior, advantages, drawbacks, and tuning for high‑performance file transfers.
The article explains the traditional Linux read/write system‑call I/O path, detailing the multiple CPU and DMA copies, context switches, page‑cache mechanisms, and advanced techniques such as zero‑copy, multiplexing, and direct I/O for performance optimization.
The article explains Linux I/O optimization through zero‑copy techniques—such as mmap + write, sendfile, and splice—detailing memory hierarchy, the benefits of reducing user‑kernel copies, the suitability of async + direct I/O for large file transfers, real‑world uses like Kafka and Nginx, and inherent platform limitations.
This article explains the principles, transfer modes, parameters, features, and register configuration of Direct Memory Access (DMA) in STM32 microcontrollers, illustrating how DMA offloads data movement from the CPU, improves performance, and integrates with peripherals, memory, and interrupt handling.
This article explains how zero‑copy techniques such as DMA, sendfile, mmap and Direct I/O reduce data copies and context switches in Linux, compares their mechanisms, advantages and drawbacks, and shows typical use cases like Kafka for high‑performance I/O.
The article explains how traditional I/O incurs four data copies and context switches, and how DMA, zero‑copy techniques such as sendfile, mmap, splice, and Direct I/O reduce copying and system calls, improving performance for disk‑to‑network data transfers in Linux.
This article explains the concept of zero‑copy I/O, how DMA offloads data movement between memory, disks and network cards, and compares practical implementations such as sendfile, mmap and Direct I/O, highlighting their benefits, limitations and typical use cases in Linux systems.
This article explains how Linux zero‑copy mechanisms such as DMA, sendfile, mmap and Direct I/O reduce data copies and context switches, detailing their operation, advantages, limitations, and real‑world usage in systems like Kafka and MySQL.
This article explains how zero‑copy techniques such as DMA, sendfile, mmap and Direct I/O reduce the four data copies and context switches normally required for disk‑to‑network transfers, improving performance for systems like Kafka and MySQL while outlining their trade‑offs.
This article provides an in‑depth overview of Linux memory architecture, including address spaces, segmentation and paging, memory allocation strategies such as the buddy and slab allocators, kernel and user‑space memory pools, DMA considerations, common pitfalls, and practical tools for monitoring and optimizing memory usage.
This article explains how DMA offloads memory‑to‑device data transfers, reduces the four data copies and context switches of traditional I/O, and introduces zero‑copy methods such as sendfile, mmap and Direct I/O, illustrating their mechanisms, advantages, limitations, and real‑world use cases like Kafka and MySQL.
This article explains how DMA offloads memory‑to‑device data transfers, reduces the four data copies and context switches of traditional I/O, and introduces zero‑copy mechanisms such as sendfile, mmap and Direct I/O, with practical examples like Kafka and MySQL.
This article explains the principles of disk I/O, covering read/write workflows, DMA acceleration, page cache, memory‑mapped files, buffering techniques, Linux kernel parameters and practical Java code examples to illustrate how to reduce CPU involvement and improve overall system performance.
The article explains the fundamentals of disk I/O, covering read/write processes, IO interrupts, DMA, page cache, mmap, buffered versus unbuffered file operations, ByteBuffer usage, Linux dirty‑page parameters, and how these mechanisms affect application performance and reliability.
This article explains how Linux traditional read/write system calls work, detailing the CPU, DMA copies and context switches involved, and then explores high‑performance I/O techniques such as zero‑copy, multiplexing and PageCache, together with the Linux I/O stack and buffering layers.
This article explains how DMA and zero‑copy techniques reduce the four memory copies and context switches typical of Linux I/O, detailing their mechanisms, implementations such as sendfile, mmap and Direct I/O, and real‑world usage in Kafka and MySQL to boost performance.
This article explains the costly four‑copy, four‑context‑switch data path in traditional Linux I/O, introduces DMA as a co‑processor that offloads memory transfers, describes zero‑copy techniques such as sendfile, mmap and Direct I/O, and shows how Kafka and MySQL leverage these methods to reduce CPU overhead and improve throughput.
This article explains the concepts of Direct Memory Access (DMA) and Remote Direct Memory Access (RDMA), compares traditional data transfer with DMA-enabled paths, outlines RDMA's advantages such as zero-copy and kernel bypass, and reviews the main RDMA protocols, standards bodies, and hardware ecosystem.
This article explains why zero‑copy techniques such as mmap, sendfile and DMA dramatically reduce CPU copies and context switches in traditional read/write I/O, improving the performance of high‑throughput systems like RocketMQ and Kafka.
Zero‑copy I/O minimizes data copying by using DMA and kernel mechanisms such as mmap + write or the sendfile() system call, with sendfile achieving true zero‑copy through fewer system calls, context switches, and memory copies compared to traditional read/write paths.
This article explains how computer buses work, the different types of buses, the role of I/O device interfaces, device controllers, DMA and interrupt controllers, and how Linux implements device drivers to provide a unified I/O subsystem.
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.
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.
Zero-copy techniques such as mmap + write, sendfile, and sendfile + DMA scatter/gather reduce CPU copies and context switches by leveraging kernel‑space data transfers and DMA, dramatically improving I/O performance for high‑throughput systems like RocketMQ and Kafka, as explained with detailed process flows and comparisons.
This article explains the core principles of DPDK memory management, covering standard huge pages, NUMA node binding, direct memory access, IOMMU and IOVA addressing, custom allocators, and memory pools, and how these mechanisms together enable high‑performance packet processing on Linux systems.
This article explains how operating systems manage diverse I/O devices through device controllers, registers, drivers, DMA, and Linux’s generic block layer, and walks through the complete sequence that occurs—from a keyboard press to the character appearing on the screen.
This article explains the principles of Linux I/O, the need for zero‑copy, the role of page and buffer caches, various data‑transfer mechanisms such as DMA, Direct I/O and mmap, and compares their performance and usage scenarios.
This article provides a comprehensive overview of Linux memory management, covering memory organization, address spaces, fragmentation causes and mitigation, kernel allocation strategies such as the buddy and slab systems, user‑space memory pools, DMA handling, usage scenarios, and typical pitfalls for developers.
This article explains how zero‑copy techniques such as DMA, mmap, and sendfile work, compares them with traditional file I/O, shows their Java NIO implementations, and presents performance test results demonstrating the advantages of mmap for small files and sendfile for large files.
This comprehensive guide explores Linux memory architecture, address spaces, allocation algorithms like the buddy system and slab allocator, DMA handling, user‑space allocation functions, and practical pitfalls, providing developers with essential insights to optimize performance and avoid common errors.
This article explains the evolution of data transfer in computers—from early CPU‑bound copying to DMA, channel architectures, and I/O processors—then demonstrates how zero‑copy techniques like sendFile and memory‑mapped I/O dramatically reduce CPU usage and improve throughput.
