Tagged articles
Shared Memory
61 articles · Page 1 of 1
The article explains how ThoughtSpot Spotter 3's conversation-based rule learning and YAML-based shared memory migration can inadvertently overwrite production business rules during deployment, and outlines a safe release process: export production rules as baseline, merge new corrections, validate with dry-run API, and verify both new and existing queries post-deployment.
API DeploymentData AgentNL2SQL
0 likes · 15 min read

This comprehensive guide covers Linux memory fundamentals, address space layout, buddy and slab allocation algorithms, kernel/user memory APIs, page fault handling, shared memory, common C/C++ memory pitfalls, and essential monitoring tools for backend developers.
C++ smart pointersLinux kernelShared Memory
0 likes · 25 min read

This article introduces thread safety by explaining threads, shared memory, and thread switching, then demonstrates a race condition where a Java counter loses increments due to non-atomic count++, and shows how synchronized fixes it by serializing access.
Java ConcurrencyShared MemorySynchronized
0 likes · 11 min read

The article analyzes why placing STL containers such as std::map, std::string, or std::vector directly in Linux shared memory leads to segmentation faults, detailing memory continuity, cross‑process pointer invalidation, and lifecycle issues, and then presents safe alternatives like fixed‑size arrays, manual memory management, and Boost.Interprocess.
C++IPCLinux
0 likes · 17 min read

The article explains why single-agent AI architectures struggle with complex tasks and argues that future AI will rely on multi‑agent systems featuring a coordinator, specialized research, planning, critic, and execution agents, shared memory or message‑passing communication, and hierarchical or decentralized coordination for scalability and robustness.
AI ArchitectureCoordinatorShared Memory
0 likes · 8 min read

The article explains how Codex can evolve from a simple code‑generation assistant into a system that automates entire computer workflows by combining durable threads, voice input, steering, queuing, browser and computer control, side‑bars, and shared memory, with concrete usage patterns and comparisons.
AI agentsCodexShared Memory
0 likes · 12 min read

The article provides a step‑by‑step guide on extending Codex beyond code generation by using persistent threads, voice input, task correction, queuing, tool integration, side‑panel displays, shared memory, and automation to create a continuous, context‑aware AI work system.
AI agentsCodexShared Memory
0 likes · 13 min read

This article explains the fundamentals of Linux memory management, details how shared memory implements zero‑copy inter‑process communication, and provides step‑by‑step code examples of system calls, mmap, sendfile, splice, and synchronization techniques for high‑performance data transfer.
IPCShared Memorymemory management
0 likes · 40 min read

This comprehensive guide breaks down Linux inter‑process communication (IPC) by explaining its core concepts, why it’s needed, and detailing six mechanisms—pipes, named pipes, message queues, shared memory, semaphores/PV operations, signals, and sockets—complete with code samples, diagrams, and real‑world usage scenarios.
IPCLinuxShared Memory
0 likes · 49 min read

This article thoroughly explains Linux shared memory, covering its advantages over other IPC methods, the kernel data structures, virtual‑physical mapping, creation and destruction APIs, copy‑on‑write behavior, and provides complete example code for inter‑process communication.
IPCShared Memoryc-programming
0 likes · 46 min read

This article traces the evolution of PHP request handling from early CGI and mod_php through PHP‑FPM to modern runtimes like Swoole, RoadRunner, and FrankenPHP, explaining their architectures, shared‑memory models, performance gains, and practical migration tips.
BackendFrankenPHPPHP
0 likes · 15 min read

This comprehensive guide explores Linux inter‑process communication (IPC), explaining why processes need to communicate, the underlying kernel mechanisms, and detailed coverage of pipes, FIFOs, signals, files, shared memory, message queues, and sockets with practical code examples and real‑world use cases.
IPCLinuxShared Memory
0 likes · 48 min read

This article explains how using mmap for shared memory in C/C++ can break process isolation, introduce permission‑related code‑injection vulnerabilities, and cause multithreading synchronization issues, making it a riskier choice than the traditional malloc allocation.
C++Shared Memorymalloc
0 likes · 5 min read

This article examines the theory and practice of shared memory in multi‑agent systems, tracing its evolution from classic blackboard models to modern solutions like Mem0.ai, Open Memory, and A‑MEM, and provides concrete design patterns, integration strategies, and future research directions for LangGraph users.
AI MemoryLLMLangGraph
0 likes · 37 min read

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.
SecurityShared Memoryc-programming
0 likes · 5 min read

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.
HTTP serverMaster ProcessShared Memory
0 likes · 9 min read

This article provides a comprehensive guide to Linux inter‑process communication (IPC), covering pipes, named pipes, signals, file‑based communication, semaphores, various shared‑memory techniques, message queues, sockets, and Unix domain sockets, each explained with concepts, typical use‑cases, diagrams and complete C code examples.
IPCInterprocess CommunicationLinux
0 likes · 32 min read

This article explains why Linux processes need to communicate, describes the kernel‑mediated IPC framework, compares shared‑memory and message‑passing approaches, and provides detailed code examples for pipes, FIFOs, signals, files, semaphores, sockets, plus real‑world use cases and case studies.
IPCInterprocess CommunicationLinux
0 likes · 31 min read

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.
C++IPCLinux
0 likes · 19 min read

This article provides a detailed, step‑by‑step overview of every Linux interprocess communication mechanism—including pipes, signals, files, semaphores, shared memory, message queues, sockets, and Unix domain sockets—complete with concepts, usage scenarios, diagrams, and full code examples.
IPCLinuxPipe
0 likes · 32 min read

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.
DMAShared Memorymmap
0 likes · 33 min read

This article introduces njs, the JavaScript engine for Nginx, explains its basic "Hello world" example and walks through advanced features such as filesystem APIs, asynchronous I/O, shared memory, response handling, logging, and the global namespace, all with concrete code snippets.
Asynchronous ProcessingJavaScriptShared Memory
0 likes · 8 min read

This guide explains the core Linux inter‑process communication mechanisms—including pipes, signals, files, semaphores, shared memory, message queues, sockets, and Unix‑domain sockets—detailing their concepts, typical use‑cases, and providing concise C code examples for each.
IPCLinuxShared Memory
0 likes · 31 min read

This article explains the Linux kernel architecture, breaks it into three layers and five key subsystems—process scheduling, memory management, virtual file system, network interface, and inter‑process communication—detailing their responsibilities, inter‑dependencies, and providing concrete code examples and diagrams.
IPCLinuxProcess Scheduling
0 likes · 29 min read

This article introduces Linux interprocess communication (IPC), describes the characteristics and usage of unnamed and named pipes, message queues, shared memory, signals, and semaphores, and provides complete C code examples and a producer‑consumer demonstration that combine these mechanisms.
IPCLinuxShared Memory
0 likes · 39 min read

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.
Linux kernelShared Memoryio_uring
0 likes · 39 min read

The article explains how to ensure data correctness in Linux inter‑process shared memory communication by using synchronization mechanisms—semaphores, mutexes, and condition variables—providing step‑by‑step code examples for each method and discussing their proper initialization, usage, and potential pitfalls.
C++IPCLinux
0 likes · 15 min read

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.
KubernetesPodShared Memory
0 likes · 11 min read

This article explains how to design and implement a fast, shared‑memory cache for a PHP‑based strategy game backend using Webman, Redis, MySQL, and APCu, covering service architecture, Redis usage, atomic operations with APCu locks, channel and list mechanisms, and practical code examples for multi‑process communication.
PHPRedisShared Memory
0 likes · 14 min read

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.
IPCLinuxShared Memory
0 likes · 19 min read

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.
AndroidPerfettoShared Memory
0 likes · 26 min read

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.
IPCLinuxShared Memory
0 likes · 15 min read

This guide explains what a process is, how it differs from a thread, various ways to create and terminate processes in Linux, and provides detailed examples of inter‑process communication mechanisms—including message queues, shared memory, UNIX domain sockets, pipes, and semaphores—complete with C code samples.
C++IPCLinux
0 likes · 31 min read

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.
HugePagesNUMAShared Memory
0 likes · 41 min read


21CTODec 20, 2022 · Fundamentals
This article explains how Linux’s free command reports memory usage, clarifies the roles of buffer and page caches, demonstrates which caches can be reclaimed, and shows why tmpfs, shared memory, and MAP_SHARED mmap allocations remain in cache until explicitly released.
CacheLinuxPage Cache
0 likes · 19 min read

This article explains how Linux’s free command reports memory usage, clarifies the roles of buffer and page caches, and demonstrates through practical experiments why certain caches—such as those used by tmpfs, shared memory, and MAP_SHARED mmap regions—cannot always be reclaimed as free memory.
CacheLinuxShared Memory
0 likes · 18 min read

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

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.
CSV comparisonPython multiprocessingShared Memory
0 likes · 8 min read

This article explains why traditional Linux kernel TCP stacks struggle with high‑performance demands, introduces shared‑memory IPC and RDMA concepts, describes the SMC‑R hybrid protocol that transparently replaces TCP sockets, and outlines practical acceleration methods and community contributions.
Kernel Network StackRDMASMC-R
0 likes · 7 min read

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.
DataLoaderPyTorchSerialization
0 likes · 7 min read

This guide explains how Linux processes share physical memory using the shmget, shmat, and shmdt system calls, detailing their prototypes, parameters, example programs, kernel structures, and the internal workings of the associated kernel functions.
IPCLinuxShared Memory
0 likes · 15 min read

This article explains Linux's shared‑memory mechanism, covering the concepts of virtual versus physical memory, the three core system calls (shmget, shmat, shmdt), example programs for two processes, and a detailed look at the kernel structures and functions that implement shared memory.
IPCLinuxShared Memory
0 likes · 13 min read

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.
GoIPCShared Memory
0 likes · 19 min read

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.
IPCLinuxShared Memory
0 likes · 7 min read

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.
PHPShared MemorySwoole
0 likes · 6 min read

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.
LinuxShared Memorycopy-on-write
0 likes · 9 min read


ITPUBOct 20, 2019 · Fundamentals
Python 3.8 introduces several practical enhancements—including the walrus operator (:=) for assignment expressions, positional‑only parameters marked by '/', runtime audit hooks, f‑string debugging with '=', improved asyncio REPL handling, shared memory support, a built‑in @cached_property decorator, and numerous performance and library updates.
3.8Shared Memoryassignment expression
0 likes · 8 min read

Python 3.8 introduces a suite of powerful language enhancements—including the assignment expression (Walrus Operator), mandatory positional‑only parameters, runtime audit hooks, cross‑process shared memory, importlib.metadata utilities, cached_property, decorator simplifications for lru_cache, an interactive asyncio REPL, f‑string debugging, AsyncMock for asynchronous testing, and iterable unpacking fixes—each illustrated with concise code examples.
AsyncMockPython 3.8Shared Memory
0 likes · 7 min read

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.
LevinShared Memorybackend infrastructure
0 likes · 6 min read


ITPUBJun 12, 2019 · Fundamentals
This article explains the principles of Linux shared memory interprocess communication, details the relevant data structures and system limits, walks through the essential API calls for creating, controlling, attaching, and detaching shared memory, and provides a full C program demonstrating parent‑child communication.
IPCInterprocess CommunicationLinux
0 likes · 7 min read

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.
Shared Memorybackend developmentnginx
0 likes · 15 min read

This article explains how Alibaba's automatic task‑pipeline system transforms deep‑learning inference for retail video streams by decoupling model execution from scheduling, using Python‑based pipelines, high‑performance shared memory, and robust fault‑tolerance, achieving up to 13% faster processing and double the camera capacity.
AI PipelinePythonShared Memory
0 likes · 22 min read

The article explains the discrepancy between the file‑handle count reported by /proc/sys/fs/file‑nr and the numbers shown by lsof, clarifying the difference between file descriptors and file handles, describing how the kernel allocates struct file objects, and showing how shared memory, mmap, and other operations can inflate handle counts unnoticed by lsof.
Shared MemorySystem Monitoringfile-descriptors
0 likes · 9 min read

This article explains Linux shared memory IPC, covering its data structures, system limits, essential API calls for creating, controlling, attaching, and detaching memory segments, conventions between parent and child processes, and provides a complete C example demonstrating interprocess communication.
IPCLinuxShared Memory
0 likes · 7 min read

This article explains the internal architecture of PHP‑FPM, covering its startup sequence, master‑worker process management, event‑driven loop, signal handling, shared‑memory scoreboard implementation, and the overall request lifecycle, with detailed code excerpts and diagrams.
BackendPHP-FPMProcess Management
0 likes · 23 min read

This article explains the Linux mmap system call, its usage, flags, error handling, related calls like munmap and msync, two shared‑memory techniques, and the underlying virtual‑address and vm_area_struct mechanisms that enable memory mapping.
Shared Memorymemory mappingmmap
0 likes · 16 min read

This article explains shared memory concepts, demonstrates how to create, read, write, and delete PHP shmop segments with code examples, discusses atomic operations using semaphores, and compares its speed against memcache and file I/O, offering practical guidance for backend developers.
BackendIPCShared Memory
0 likes · 11 min read


ITPUBJun 16, 2016 · Databases
This guide explains two powerful Linux commands that instantly terminate all Oracle-related processes and clean up shared memory, providing a quick recovery method for stuck Oracle databases while warning of the risks involved.
LinuxOracleProcess Management
0 likes · 5 min read

This article explains how the Linux free command reports memory usage, clarifies the roles of buffer and page cache, shows how to manually drop caches, and reveals scenarios—such as tmpfs, shared memory, and mmap—where cached memory cannot be reclaimed, helping readers achieve a deeper understanding of system memory behavior.
Buffer CacheCachePage Cache
0 likes · 14 min read

This article explains how the Linux free command reports memory usage, clarifies the roles of buffer cache and page cache, demonstrates which cache memory can be reclaimed, and shows practical tests using tmpfs, shared memory, and mmap with code examples.
Buffer CacheLinuxPage Cache
0 likes · 17 min read

This article demystifies the Linux free command, explains the distinction between buffer and page caches, shows how various caches are reclaimed—or not—through practical tests with tmpfs, shared memory, and mmap, and provides actionable tips for accurately interpreting memory usage on RHEL 6 systems.
LinuxShared Memoryfree command
0 likes · 15 min read
