0 views collected around this technical thread.
This article explains the problems of memory fragmentation and allocation inefficiency in C++ programs, introduces the concept of memory pools, discusses their design principles, advantages, and common implementations, and provides a complete example of a thread‑safe fixed‑size memory pool with code.
This article explains the concept of memory pools, how they reduce allocation overhead and fragmentation compared to traditional malloc/new, describes various pool designs and Linux kernel APIs, provides multiple C and C++ implementations, and discusses performance benefits and typical application scenarios such as servers, real‑time and embedded systems.
This article explains the problems of frequent new/delete in C++, introduces memory‑pool concepts, details design principles, outlines a multi‑layer architecture (Thread Cache, Central Cache, Page Cache), provides a complete C++ implementation compatible with std::allocator, and discusses common pitfalls and performance considerations.
This article explores the internal structure and growth mechanism of Go's bytes.Buffer, demonstrates how the GWS library replaces gorilla/websocket, and presents a high‑performance bytes.Buffer pool implementation using sync.Pool with power‑of‑two sizing to reduce allocations and improve concurrency in backend services.
This article explains the concept, benefits, and implementation details of memory pools in the Linux kernel, covering allocation functions, design principles, common strategies, and a thread‑safe C++ memory‑pool class with example code.
This article explains Netty's memory pool architecture after switching from jemalloc3 to jemalloc4, detailing the new memory size classes, core components such as PoolArena, PoolChunkList, PoolChunk, and PoolSubpage, and provides Java code snippets to illustrate their implementations.
This article presents a comprehensive design and implementation of a high‑concurrency memory pool in C++, covering concepts such as fixed‑size block allocation, thread‑local caches, central and page caches, lock‑free techniques, span management, and performance benchmarking against standard malloc.
This article explains the concept of pooling technology, its advantages, and its practical applications in Java—including thread pools, memory pools, database connection pools, and HttpClient connection pools—while highlighting how these techniques improve performance, resource utilization, and system stability.
This article explains Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool implementation, illustrating how these components together achieve scalability and low latency.
This article revisits memory allocation and reclamation concepts by examining Java's Netty memory pool implementation, its theoretical basis in jemalloc, and practical design choices such as arena allocation, thread‑local caches, pool chunks, sub‑pages, and multi‑threaded performance considerations.
This article explains the concept of pooling—pre‑creating reusable resources—and demonstrates how thread pools, memory pools, database connection pools, and HttpClient pools improve Java application performance, backed by code examples and benchmark results.
This article explains the concept of pooling technology in Java, illustrating its benefits through real‑world analogies, detailing thread pools, memory pools, database connection pools, and HttpClient pools, and provides a performance comparison between raw threads and thread pools using a Java benchmark.
This article explains Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool mechanism, and compares it with traditional web servers.
The article analyzes why Go's ioutil.ReadAll becomes a performance bottleneck in IO‑intensive workloads after CPU microcode patches, explains the underlying buffer reallocations, and presents a multi‑level memory‑pool design that reduces allocations and achieves roughly a 19‑fold speedup.