How do I use Hoard with my C++ program on Linux without changing code?

Set the LD_PRELOAD environment variable to point to libhoard.so before running your program, or link it during compilation. This allows Hoard to intercept malloc calls seamlessly.

Hoard vs jemalloc: which is better for multithreaded servers?

Both improve scalability, but Hoard offers provable memory bounds and false sharing prevention, while jemalloc is more common in systems like FreeBSD. Test both with your specific workload to decide.

Does Hoard work with programs that have custom memory allocators?

Hoard replaces system malloc, so if a program overrides malloc with its own allocator, Hoard may not function correctly. It's best suited for standard allocation patterns.

How to install Hoard on macOS quickly?

Use Homebrew: run 'brew tap emeryberger/hoard' and 'brew install --HEAD emeryberger/hoard/libhoard', then use the 'hoard' command to launch applications with Hoard enabled.

What are the performance impacts of Hoard on single-core machines?

Performance might be similar or slightly worse due to overhead, as Hoard is optimized for multiprocessor systems. For single-core use, standard malloc could be more efficient.

Is Hoard safe for production use in critical systems?

Yes, companies like Reuters and SAP use Hoard in production, and it's included in benchmarks like SPEC CPU2006, indicating reliability and performance in real-world scenarios.

Hoard

Apache-2.0C++3.2

A fast, scalable, and memory-efficient drop-in replacement for malloc that improves performance of multithreaded applications on multicore systems.

Visit Website

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.

Target Audience

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.

Value Proposition

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

Related Projects

Community-curated · Updated weekly · 100% open source

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.

Submit a project Star on GitHub

GitHub

1.2k stars135 forks0 contributors

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

Drop-in Compatibility

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.

Multiprocessor Scalability

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.

False Sharing Prevention

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.

Provable Memory Bounds

Guarantees bounded memory consumption, preventing blowup where memory needs scale with processor count, a key advantage over standard allocators.

Cons

Windows Static Runtime Incompatibility

Only works with programs compiled using /MD (dynamic C runtime) on Windows; /MT-compiled executables cannot be intercepted, limiting compatibility for some projects.

Setup Complexity on Windows

Requires using tools like withdll.exe or setdll.exe for injection, which adds extra steps and potential confusion compared to simpler Unix-like linking.

Overhead for Single-threaded Use

Optimized for multithreading, so it may introduce unnecessary overhead in single-threaded applications, potentially reducing performance in non-concurrent scenarios.

Frequently Asked Questions

Home

C/C++

mimalloc

mimalloc is a compact general purpose allocator with excellent performance.

Stars13,081

Forks1,123

Last commit1 month ago

TCMalloc

TCMalloc 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.

The Boehm-Demers-Weiser conservative C/C++ Garbage Collector (bdwgc, also known as bdw-gc, boehm-gc, libgc)

Stars3,486

Forks438

Last commit12 days ago

rpmalloc

Public domain cross platform lock free thread caching 16-byte aligned memory allocator implemented in C

#performance-optimization