Hoard
A fast, scalable, and memory-efficient drop-in replacement for malloc that improves performance of multithreaded applications on multicore systems.
What is Hoard?
Hoard is a memory allocator that serves as a drop-in replacement for system malloc, designed to improve the performance of multithreaded applications running on multiprocessor and multicore systems. It solves problems like heap contention, false sharing, and memory blowup that plague standard allocators in concurrent environments. The allocator works across Linux, Windows, and macOS without requiring any changes to application source code.
Developers building performance-critical multithreaded applications in C or C++ that run on multicore systems, particularly those experiencing scalability bottlenecks due to memory allocation. It's also valuable for system programmers and engineers working on servers, telephony systems, computational toolkits, and other allocation-intensive software.
Developers choose Hoard because it provides provable performance and memory guarantees while being completely transparent to existing code. Unlike standard allocators, it eliminates scalability bottlenecks, prevents false sharing, and bounds memory consumption—all through simple linking or environment variable configuration.
Overview
The Hoard Memory Allocator: A Fast, Scalable, and Memory-efficient Malloc for Linux, Windows, and Mac.
Use Cases
Best For
- Improving scalability of multithreaded C++ applications using the Standard Template Library (STL)
- Eliminating heap contention bottlenecks in server applications running on multicore processors
- Preventing false sharing in concurrent programs where threads access adjacent memory locations
- Bounding memory consumption in allocation-intensive parallel applications
- Replacing system malloc in telephony servers, computational fluid dynamics toolkits, and web proxies
- Running benchmarks and performance tests where memory allocator overhead affects results
Not Ideal For
- Single-threaded applications running on single-core processors, as Hoard's optimizations are targeted at concurrency
- Windows programs compiled with the /MT (static C runtime) flag, since Hoard cannot intercept allocations in such executables
- Projects with extremely low memory allocation frequency where the overhead of a specialized allocator might not justify the benefits
- Environments requiring deterministic, real-time allocation behavior, as Hoard focuses on scalability rather than predictability
Pros & Cons
Pros
Requires no source code changes; works by linking or setting environment variables like LD_PRELOAD on Linux, making it easy to integrate with existing applications.
Eliminates heap contention that serializes threads, allowing programs to scale with CPU count, as evidenced by use in servers from companies like Cisco and SAP.
Designed to prevent threads on different CPUs from accessing memory in the same cache line, avoiding performance degradation that can be hundreds of times slower.
Guarantees bounded memory consumption, preventing blowup where memory needs scale with processor count, a key advantage over standard allocators.
Cons
Only works with programs compiled using /MD (dynamic C runtime) on Windows; /MT-compiled executables cannot be intercepted, limiting compatibility for some projects.
Requires using tools like withdll.exe or setdll.exe for injection, which adds extra steps and potential confusion compared to simpler Unix-like linking.
Optimized for multithreading, so it may introduce unnecessary overhead in single-threaded applications, potentially reducing performance in non-concurrent scenarios.
Frequently Asked Questions
Related Projects
mimallocmimalloc is a compact general purpose allocator with excellent performance.
TCMallocTCMalloc is Google's customized implementation of C's `malloc()` and C++'s `operator new` for memory allocation within C and C++ code. It provides a high-performance alternative to standard memory allocators, optimized for multi-threaded applications where allocation speed and scalability are critical. ## Key Features - **Fast Allocation** — Optimized for speed with efficient memory management algorithms - **Multi-threaded Performance** — Designed to scale well in concurrent environments - **Customizable Configuration** — Tunable parameters for different workload requirements - **Comprehensive API** — Full support for C and C++ memory allocation interfaces - **Platform Support** — Available across multiple operating systems and architectures ## Philosophy TCMalloc prioritizes performance and scalability in multi-threaded environments while maintaining compatibility with standard memory allocation interfaces, making it suitable for production systems with demanding memory allocation patterns.
Boehm GCThe Boehm-Demers-Weiser conservative C/C++ Garbage Collector (bdwgc, also known as bdw-gc, boehm-gc, libgc)
rpmallocPublic domain cross platform lock free thread caching 16-byte aligned memory allocator implemented in C
Found a gem we're missing?
Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.