# jemalloc — Scalable Concurrent Memory Allocator

> jemalloc is a general-purpose memory allocator that emphasizes fragmentation avoidance and scalable concurrency support. Originally developed for FreeBSD, it is used by Firefox, Redis, Facebook, and many other performance-critical systems.

## Install

Save in your project root:

# jemalloc — Scalable Concurrent Memory Allocator

## Quick Use
```bash
# Install
sudo apt install libjemalloc-dev
# Use via LD_PRELOAD (no recompilation)
LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libjemalloc.so ./my_app
# Or link at compile time
gcc -o my_app main.c -ljemalloc
# Enable profiling
MALLOC_CONF=prof:true,prof_prefix:jeprof ./my_app
```

## Introduction
jemalloc is a general-purpose malloc implementation that was created for FreeBSD in 2005 and has since become one of the most widely deployed high-performance memory allocators. It reduces memory fragmentation and contention on multi-core systems through a design based on thread-local caches and size-class-segregated arenas.

## What jemalloc Does
- Replaces the system malloc with a drop-in alternative optimized for multi-threaded workloads
- Reduces memory fragmentation through size-class binning and slab-based allocation
- Minimizes lock contention by assigning threads to independent arenas with thread-local caches
- Provides heap profiling to track allocation sites and identify memory leaks or hot paths
- Supports runtime configuration via the `MALLOC_CONF` environment variable

## Architecture Overview
jemalloc organizes memory into multiple arenas, each managing its own set of size-class bins. Threads are round-robin assigned to arenas on first allocation, and each thread maintains a local cache (tcache) of recently freed objects to satisfy most allocations without touching shared state. Large allocations bypass bins and go directly to page-level management. This multi-layered approach ensures that most allocations are lock-free, falling back to arena-level mutexes only when the tcache is exhausted or refilled.

## Self-Hosting & Configuration
- Install via package manager: `apt install libjemalloc-dev` or `brew install jemalloc`
- Build from source: `./autogen.sh && make && sudo make install`
- Use `LD_PRELOAD` to transparently replace system malloc without recompiling your application
- Configure via `MALLOC_CONF` environment variable (e.g., `narenas:4,tcache:true,prof:true`)
- Enable stats with `MALLOC_CONF=stats_print:true` to dump allocation statistics on exit

## Key Features
- Thread-local caches eliminate lock contention for the common allocation fast path
- Heap profiling with call-stack attribution to locate allocation hotspots and leaks
- Configurable arena count allows tuning for specific hardware (NUMA-aware setups)
- Transparent huge page (THP) support reduces TLB misses for large working sets
- Extensive statistics API (`mallctl`) for real-time monitoring of memory usage patterns

## Comparison with Similar Tools
- **glibc ptmalloc2** — the default Linux allocator; jemalloc reduces fragmentation and scales better on many cores
- **tcmalloc (Google)** — similar thread-caching design; jemalloc often wins on fragmentation metrics
- **mimalloc (Microsoft)** — newer allocator with excellent single-threaded throughput; jemalloc has deeper profiling and tuning options
- **Hoard** — academic allocator focused on scalability; jemalloc combines scalability with production hardening
- **musl malloc** — minimal allocator for small binaries; jemalloc targets maximum throughput and diagnostics

## FAQ
**Q: How do I use jemalloc without recompiling my application?**
A: Set `LD_PRELOAD=/path/to/libjemalloc.so` before launching your process. This replaces malloc/free at the dynamic linker level.

**Q: Does Redis use jemalloc?**
A: Yes. Redis bundles jemalloc as its default allocator on Linux for better memory efficiency.

**Q: How do I profile heap allocations?**
A: Build jemalloc with `--enable-prof`, run with `MALLOC_CONF=prof:true`, then analyze the output with `jeprof` (a fork of Google's pprof).

**Q: Can jemalloc reduce memory usage for my application?**
A: It depends. jemalloc typically reduces fragmentation-related memory waste on long-running multi-threaded services. Short-lived processes may not see significant benefit.

## Sources
- https://github.com/jemalloc/jemalloc
- https://jemalloc.net/

---
Source: https://tokrepo.com/en/workflows/asset-3c38b840
Author: AI Open Source