1 views collected around this technical thread.
mmap shared memory lets multiple processes access the same physical memory, which can break process isolation, expose permission misconfigurations like PROT_EXEC, and cause cross‑process crashes or code‑injection attacks, making it far riskier than heap allocations with malloc that remain confined to a single process.
The article shows how adding HTML tags turns a plain‑text file into a web page, explains the need for an HTTP service to serve it, introduces reverse proxies for load‑balancing and address hiding, and outlines Nginx’s event‑driven architecture with master and worker processes, shared memory, proxy cache, multi‑protocol support, configurable modules, and scaling options, while warning of a single‑instance failure and recommending cluster mode.
This article explains the fundamentals of shared memory as an efficient inter‑process communication method on Linux, covering its principles, core system calls, usage steps, advantages, synchronization challenges, and real‑world case studies with complete C code examples.
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.
This article provides a comprehensive overview of Linux's io_uring, explaining its design goals, shared‑memory mechanism, submission and completion queues, core system calls, performance advantages over traditional I/O models, typical use cases, and includes a complete example of a network server built with io_uring.
During a production deployment of large language model training on Kubernetes, a pod failed due to insufficient /dev/shm shared memory; the article details the root cause, explores missing pod spec parameters, and presents a complete solution using an emptyDir volume with medium: Memory and sizeLimit to configure shared memory.
This article explains Linux's mmap mechanism, its relationship with shared memory, the advantages and disadvantages of mmap versus traditional shared memory, and provides practical code examples and detailed steps for using mmap in interprocess communication and large‑file handling.
Perfetto’s tracing system links multiple producers to a single consumer via shared‑memory buffers, where careful sizing of pages, chunks, and central buffers, along with tuned protobuf encoding and scheduling priorities, mitigates CPU overhead and prevents data loss, enabling reliable observability on Android devices.
This article explains how Linux processes can share large data efficiently by creating a memory file with memfd_create, mapping it with mmap, and transferring the file descriptor over a Unix Domain Socket, while detailing the kernel mechanisms that enable true cross‑process memory sharing.
This article explains the fundamentals of memory‑mapped files in Linux, covering the mmap/munmap interfaces, mapping types, protection flags, error handling, virtual‑memory structures, kernel implementation details, driver examples, and practical use‑cases such as shared memory and high‑performance I/O.
This article explains DPDK's memory management architecture, covering the hierarchical memory layout, hugepage discovery and mapping, shared configuration structures, NUMA‑aware allocation, custom malloc‑heap implementation, memzone and mempool creation, and the mbuf buffer model, with detailed code examples.
This article explains PHP's two shared memory interfaces, shm and shmop, details the primary shmop functions, provides code examples for creating, reading, writing, and deleting shared memory segments, demonstrates testing with Linux commands, and includes a practical class‑based usage example.
This article outlines the testing plan for a data download refactoring project involving over 400 metrics, describes automated CSV comparison scripts, evaluates single‑process, multithreaded, and multiprocess approaches with shared memory, and provides practical recommendations for improving verification efficiency and performance.
This article explains the internal mechanism of PyTorch's DataLoader when using multiple worker processes, detailing how tensors are serialized, shared via multiprocessing.Queue, and reconstructed in the main process to avoid unnecessary memory copies.
The article explains Linux shared‑memory fundamentals, why it outperforms file‑based IPC, demonstrates the mmap() system call, and walks through a complete Go implementation that creates, synchronizes, reads, and protobuf‑serializes advertising‑tracking metrics in the VCS monitoring platform.
This article introduces several Linux interprocess communication mechanisms—including pipes, message queues, shared memory, semaphores, signals, and sockets—explaining their principles, advantages, drawbacks, and typical usage scenarios for developers preparing for system‑level programming or interviews.
This article explains how Swoole's multi‑process model isolates memory in PHP, recommends external storage such as Redis or shared memory via Swoole/Table, details capacity calculations, handling of oversized strings, and provides a complete PHP example demonstrating table creation, data storage, and server communication.
This article explains the Linux mmap system call, covering virtual address space fundamentals, how mmap interacts with the page cache and inode structures, typical use‑cases such as shared memory and anonymous mappings, code examples, and special considerations like alignment, copy‑on‑write and memory swapping.
Levin, Didi’s open‑source GitHub project, uses shared‑memory containers and offline‑compiled binary layouts to mmap large, low‑frequency static datasets, cutting service cold‑start times from minutes to seconds, lowering memory overhead, simplifying version switches, and improving stability for high‑scale applications.
This article explains how Nginx obtains and releases shared memory on Unix and Windows, describes the unified ngx_shm_alloc/ngx_shm_free interfaces, and details the slab allocator’s page‑level and small‑block management, including allocation strategies, bitmap handling, and fragmentation issues.