A detailed post‑mortem of a high‑priority fault on AMD servers shows how a split‑lock triggered by Python UDFs caused CPI spikes, CPU overload, and bus‑lock events, and explains the investigation steps, code analysis, reproduction tests, and mitigation measures taken to restore stability.
After migrating thousands of Java cores to Rust, the team used jemalloc and pprof profiling to pinpoint why a few services only improved 10%, refactored the OSS client for reuse, and achieved up to 20% CPU reduction and significant memory savings, demonstrating the power of deep performance analysis in production Rust services.
The article outlines seven practical performance‑optimization techniques for high‑throughput back‑ends—including replacing protobuf with native C++ classes, adopting cache‑friendly data structures, using jemalloc/tcmalloc, implementing lock‑free double buffers, simplifying structs for specific scenarios, and leveraging profiling tools—while stressing balanced, incremental improvements.
This article explains MySQL's memory architecture, why memory usage often stays high after spikes, and provides practical steps—including connection checks, slow query analysis, workload scaling, and switching to jemalloc—to diagnose and reduce memory consumption on 360's internal cloud platform.
This article walks through a real-world investigation of memory leaks in a Rust-based frontend service, detailing common leak scenarios, profiling tools like tokio-console and jemalloc, load testing with k6, and the step-by-step analysis that uncovered regex misuse and cache bugs, ultimately stabilizing memory usage.
This article provides a comprehensive overview of Jemalloc, covering its architecture, memory allocation fundamentals, performance comparison with ptmalloc and tcmalloc, practical optimization cases across web, database, and big‑data workloads, and detailed configuration guidelines to improve memory efficiency and multithreaded performance.
The article examines a production RocksDB memory‑usage problem where two instances consumed 59 GB on a 32‑CPU, 64‑GB server, identifies glibc ptmalloc’s unreclaimed free memory as the main cause, and shows that switching to jemalloc cuts usage by roughly 25 % while improving I/O and CPU efficiency.
The article examines a real‑world memory alarm in a Vivo service, explains how glibc’s ptmalloc allocator manages heap memory via brk, sbrk, and mmap, shows why freed chunks stay in bins, and recommends limiting heap growth or switching to jemalloc for faster reclamation.
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 explains Redis's memory model—including memory statistics, allocation, internal data structures, object types, and encoding—while showing practical examples for estimating usage, optimizing consumption, and troubleshooting fragmentation in high‑concurrency environments.
The article presents practical backend performance optimization methods—including substituting Protobuf with native C++ classes, employing cache‑friendly data structures, integrating jemalloc/tcmalloc, using lock‑free double‑buffer designs, and tailoring data formats—to achieve up to three‑fold speed improvements and significant latency reductions.
This article walks through a series‑by‑step performance‑tuning process for high‑throughput C++ services, replacing Protobuf with plain classes, adopting cache‑friendly hash tables, switching to jemalloc, implementing a double‑buffer lock‑free data structure, and tailoring data formats, each backed by concrete code examples, benchmark results, and analysis of trade‑offs.
This article presents practical performance‑optimization strategies for high‑throughput C++ services, including replacing Protobuf with hand‑written classes, adopting cache‑friendly data structures, using jemalloc/tcmalloc instead of the default allocator, employing lock‑free double‑buffer designs, tailoring data formats for specific workloads, and leveraging profiling tools to measure gains.
The article outlines practical, continuous performance‑optimization tactics for high‑throughput back‑end services—replacing Protobuf with lightweight C++ classes, using cache‑friendly data structures, adopting jemalloc/tcmalloc, employing lock‑free double buffers, tailoring data formats, and leveraging profiling tools—to achieve multi‑fold speedups while balancing maintainability.
This article analyzes a MySQL 5.7 OOM incident triggered by a heavy full‑text query, examines memory usage patterns with Tcmalloc, demonstrates how switching to Jemalloc releases memory, and provides step‑by‑step commands and observations to prevent similar outages.
This article explains how Netty implements memory management by borrowing concepts from Jemalloc and Tcmalloc, detailing the hierarchy of arenas, chunks, pages and sub‑pages, the allocation algorithms for both large and small buffers, and the role of thread‑local caches in reducing fragmentation and improving performance.
The iQIYI backend team traced random OOM crashes in PyTorch Distributed Data Parallel on an A100 cluster to a malformed DDP message injected by a security scan, which forced a near‑terabyte allocation; using jemalloc for diagnostics, they mitigated the issue by adjusting scan policies and collaborating with PyTorch to harden the protocol.
This article explains the fundamentals of Linux memory allocation, introduces Jemalloc’s core algorithms and data structures, and provides concrete optimization steps—including arena tuning, tcache configuration, and slab size adjustments—to achieve measurable CPU savings in high‑concurrency C++ services.
This article details the systematic reduction of memory consumption for Ctrip's hotel query service by halving container memory, evaluating and tuning modern garbage collectors, diagnosing off‑heap leaks, and ultimately replacing the default ptmalloc allocator with jemalloc to achieve stable performance and lower resource costs.
This article details how long JVM garbage‑collection pauses and glibc ptmalloc memory‑fragmentation caused container OOM kills in a hotel‑pricing system, and explains the step‑by‑step diagnosis, JVM tuning, Kubernetes health‑check adjustments, and the replacement of ptmalloc with jemalloc to eliminate the issue.
This article examines the design goals, key implementation details, strengths and weaknesses of four widely used memory allocators—dlmalloc, jemalloc, Scudo, and PartitionAlloc—highlighting how they address fragmentation, performance, and security in virtual‑machine runtimes and offering guidance for building efficient, safe allocators.
By adding model warm‑up files, separating load/unload threads, switching to the Jemalloc allocator, and isolating TensorFlow’s parameter memory from RPC request buffers, iQIYI’s engineers reduced TensorFlow Serving hot‑update latency spikes in high‑throughput CTR recommendation services from over 120 ms to about 2 ms, eliminating jitter.
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 Redis's memory model by describing how to query memory usage, the roles of used_memory, used_memory_rss, mem_fragmentation_ratio, and mem_allocator, and then dives into the internal structures such as redisObject, SDS, jemalloc, and the encoding strategies for strings, lists, hashes, sets, and sorted sets.
This guide walks you through seven practical optimization methods for Kunpeng‑based servers—including compiler flags, buffer selection, result caching, memory‑copy reduction, lock refinement, jemalloc integration, and cache‑line alignment—to fully exploit the hardware’s capabilities.
This article explains Redis's memory model—including memory statistics, allocation, object structures, internal encodings, and practical optimization techniques—so developers can accurately estimate memory usage, reduce fragmentation, and improve performance of high‑concurrency applications.
This article explains Redis's memory model—including memory statistics, allocation strategies, object types, internal encodings, and practical optimization techniques—so developers can accurately estimate memory usage, reduce fragmentation, and improve overall system efficiency.
This article presents a detailed investigation of occasional Redis connection errors in a large‑scale production environment, analyzing network packets, TCP backlog behavior, Redis internal client‑cron logic, jemalloc memory reclamation, and ultimately resolving the issue by adjusting query‑buffer handling and upgrading Redis to a newer version.
This article explains how to monitor Redis memory usage with the INFO command, interprets key metrics such as used_memory, used_memory_rss, and mem_fragmentation_ratio, and dives into Redis's internal memory layout, including allocators, redisObject, SDS, and the various object types and their encodings.
This article explains Redis's memory model—including memory statistics, allocation, object structures, internal encoding, and practical optimization techniques—so developers can accurately estimate memory usage, reduce fragmentation, and choose the most efficient data representations for high‑performance applications.
This article explains Redis’s memory model—including memory statistics, allocation, object structures, internal encodings, and practical optimization strategies—providing detailed insights into how Redis stores data, manages memory fragmentation, and how developers can estimate and reduce memory usage for high‑performance deployments.
