How and Why Redis Overrides Malloc: Deep Dive into jemalloc and tcmalloc

Introduction: Why Redis Overrides Standard Malloc

Redis, being an in-memory database, performs a high volume of in-memory reads and writes. This intensive activity necessitates frequent allocation and deallocation of heap data. Often, these operations involve small objects, such as keys, values, or basic incrementation operations. For a system designed for extreme efficiency and performance, relying solely on the operating system’s default memory allocator (malloc) can introduce significant bottlenecks and inefficiencies.

Limitations of Standard malloc

While malloc is the standard for memory allocation in C, it presents several challenges for high-performance, in-memory systems like Redis:

Memory Fragmentation

When an application frequently allocates and frees memory chunks of varying sizes, the heap can become fragmented. This means that while there might be enough total free memory, it’s scattered in small, non-contiguous blocks. For example, if four small chunks are allocated, and then the middle two are freed, the remaining free space is “fragmented” between the still-allocated chunks. This makes it difficult to fulfill subsequent larger allocation requests, even if the total free memory is sufficient, leading to wasted space and potential allocation failures.

Inefficient Operating System Page Management

Standard malloc implementations typically interact directly with the operating system for memory requests. Operating systems manage memory in fixed-size units called pages, often 4096 bytes (4KB). When an application requests memory, even a small amount (e.g., a few bytes), the OS might allocate an entire 4KB page to fulfill that request. For applications like Redis that frequently allocate many small objects, this can lead to significant internal fragmentation within pages, where much of the allocated page remains unused. This results in inefficient memory utilization.

Concurrency Challenges

Traditional malloc implementations may not be optimized for highly concurrent environments. In a multi-threaded application, concurrent memory allocation and deallocation requests can lead to contention, locking overhead, and reduced throughput, impacting overall system performance.

Introducing Specialized Memory Allocators: jemalloc and tcmalloc

To overcome the limitations of standard malloc, high-performance systems often turn to specialized memory allocation libraries. Redis leverages such libraries, specifically jemalloc (developed by Facebook) and tcmalloc (developed by Google). These are alternative malloc implementations designed from the ground up for performance, concurrency, and efficient memory management in demanding applications.

How jemalloc and tcmalloc Work

jemalloc and tcmalloc operate by taking a more proactive and optimized approach to memory management:

• Internal Memory Management: Instead of requesting small chunks directly from the OS, these allocators acquire larger blocks of memory (arenas or spans) from the operating system. They then manage the allocation and deallocation of smaller objects within these larger blocks internally. This reduces the frequency of expensive system calls.
• Defragmentation: They employ sophisticated algorithms to minimize and manage memory fragmentation. This includes techniques like object pooling, size-class allocation, and potentially compaction (though less common for general-purpose allocators) to ensure memory is utilized as efficiently as possible.
• Concurrency Control: Both jemalloc and tcmalloc are designed with concurrency in mind. They often use per-thread caches or arenas to reduce contention during concurrent allocation requests, allowing multiple threads to allocate memory without blocking each other.
• Configurability: A key advantage is their extensive configurability. Developers can tune various parameters to optimize memory management behavior for specific application workloads and hardware architectures, ensuring the best possible performance for their use case.

Redis’s Integration with Custom Allocators

Redis integrates jemalloc and tcmalloc through its own memory allocation wrapper, zmalloc.

• zmalloc.h and zmalloc.c: Redis’s source code includes zmalloc.h and zmalloc.c, which abstract the underlying memory allocation calls. This allows Redis to use a consistent API while dynamically choosing the actual allocator.
• Conditional Compilation: Within zmalloc.h, Redis uses preprocessor directives (#ifdef USE_TCMALLOC, #ifdef USE_JEMALLOC) to conditionally compile against jemalloc, tcmalloc, or the system’s default malloc. This means that during compilation, based on defined flags, Redis can be built to link against a specific allocator.
• Default on Unix Systems: When compiling Redis on many Unix-like operating systems (e.g., Ubuntu), jemalloc is often the default choice due to its proven performance benefits.
• Flexibility: Redis provides the flexibility to switch between these implementations or even revert to the native malloc. This allows users to benchmark different allocators in their specific environment and choose the one that offers the best performance for their workload.

Benefits for Redis

By overriding the standard malloc with jemalloc or tcmalloc, Redis achieves significant advantages:

• Enhanced Performance: Faster and more predictable memory allocation and deallocation cycles, crucial for an in-memory database.
• Reduced Memory Fragmentation: More efficient use of physical memory, leading to less wasted space and improved cache locality.
• Optimized for Small Objects: Better handling of the numerous small key-value pairs and other data structures that Redis manages.
• Improved Concurrency: Handles high-volume concurrent memory operations more effectively, supporting Redis’s single-threaded event loop model by ensuring memory operations are not a bottleneck.

Conclusion

For high-scale, performance-critical projects like Redis, relying solely on the native malloc implementation provided by the operating system’s glibc is often insufficient. Custom memory allocators such as jemalloc and tcmalloc offer the fine-grained control, optimization, and performance characteristics necessary to meet the demanding requirements of an in-memory database. By intelligently managing memory, reducing fragmentation, and optimizing for concurrency, these specialized allocators play a vital role in Redis’s ability to deliver exceptional speed and efficiency.