mulle_allocator Valgrind Integration: Debugging Custom Memory Allocators

Yes, mulle_allocator works seamlessly with Valgrind when using the built-in stdlib wrapper, which forwards all allocation calls to the standard C library functions that Valgrind instruments by default.

The mulle-c/mulle-allocator repository provides a thin, portable abstraction layer over the C heap that enables pluggable memory management strategies. Because the default implementation ultimately dispatches to standard malloc family functions, you can analyze memory usage, detect leaks, and identify buffer overruns using Valgrind without modifying your application code or recompiling the library.

How mulle_allocator Interfaces with Valgrind

The core abstraction is the struct mulle_allocator defined in src/mulle-allocator.h. This structure contains function pointers for calloc, realloc, free, a failure handler, and optional ABA-free hooks.

struct mulle_allocator
{
   void *(*calloc)(size_t, size_t, struct mulle_allocator *);
   void *(*realloc)(void *, size_t, struct mulle_allocator *);
   void (*free)(void *, struct mulle_allocator *);
   void (*fail)(struct mulle_allocator *, void *, size_t) MULLE_C_NO_RETURN;
   int   (*abafree)(void *, void (*)(void *, void *), void *, void *);
   void  *aba;
};

The Default stdlib Allocator

The library ships with mulle_allocator_stdlib, a global instance declared in src/mulle-allocator.c. Its calloc, realloc, and free members forward directly to the system calloc, realloc, and free through internal v_* wrapper functions. When you use mulle_default_allocator (which is initialized as a copy of the stdlib allocator), every allocation follows this path:

mulle_allocator_* → v_calloc / v_realloc / v_free → libc malloc/realloc/free → Valgrind

Because the implementation at lines 77-99 of src/mulle-allocator.c ultimately calls the GNU C library allocation functions, Valgrind’s Memcheck intercepts every operation automatically.

Using the stdlib Allocator for Immediate Debugging

To ensure full Valgrind visibility, pass &mulle_allocator_stdlib (or the convenience macro mulle_stdlib_allocator) to your API calls. This configuration requires no special build flags or Valgrind-specific code.

#include <mulle-allocator.h>

int main(void)
{
    struct mulle_allocator *alloc = &mulle_stdlib_allocator;
    
    char *msg = mulle_allocator_strdup(alloc, "Hello, Valgrind!");
    /* Valgrind tracks this allocation automatically */
    alloc->free(msg, alloc);
    return 0;
}

Running valgrind ./a.out reports the allocation and corresponding free without false positives.

Custom Allocators and Valgrind Visibility

When you replace the default allocator with a custom implementation—such as a bump-pointer arena or slab allocator that manages memory via mmap or a private heap—Valgrind cannot see those blocks. In this scenario, you must explicitly inform Valgrind about the pool lifecycle.

Adding Valgrind Client Requests

To maintain debuggability with custom pools, implement a wrapper allocator that forwards to the standard heap while emitting Valgrind client-request macros. The aba and abafree fields in struct mulle_allocator are specifically designed for external pool management; you can store a pool handle in aba and emit VALGRIND_CREATE_MEMPOOL, VALGRIND_MEMPOOL_ALLOC, and VALGRIND_DESTROY_MEMPOOL annotations inside your callbacks.

#include <mulle-allocator.h>
#include <valgrind/memcheck.h>

static void *pool_calloc(size_t n, size_t size,
                         struct mulle_allocator *a)
{
    void *p = calloc(n, size);
    VALGRIND_CREATE_MEMPOOL(p, 0, 0);
    return p;
}

static void *pool_realloc(void *ptr, size_t size,
                          struct mulle_allocator *a)
{
    void *newp = realloc(ptr, size);
    if (newp != ptr) {
        VALGRIND_DESTROY_MEMPOOL(ptr);
        VALGRIND_CREATE_MEMPOOL(newp, 0, 0);
    }
    return newp;
}

static void pool_free(void *ptr, struct mulle_allocator *a)
{
    VALGRIND_DESTROY_MEMPOOL(ptr);
    free(ptr);
}

struct mulle_allocator pool_allocator = {
    pool_calloc,
    pool_realloc,
    pool_free,
    mulle_allocation_fail,
    mulle_allocator_no_aba_abort,
    NULL
};

Because pool_calloc, pool_realloc, and pool_free forward to the standard heap and issue Valgrind pool-management requests, Valgrind correctly attributes each allocation to the custom pool while still checking for leaks and overruns.

Key Source Files and Functions

Understanding the following files is essential for implementing Valgrind-compatible custom allocators:

• src/mulle-allocator.h – Defines struct mulle_allocator and the public API, including the abafree hook signature.
• src/mulle-allocator.c – Contains the default stdlib allocator implementation (v_calloc, v_realloc, v_free at lines 77-99) and global instances mulle_allocator_stdlib and mulle_allocator_stdlib_nofree.
• src/mulle-memset.c – Provides low-level memory utilities used by the test suite; useful for verifying memory writes under Valgrind.
• test/ – Example programs exercising the allocator; run these under Valgrind to validate your integration.

Summary

• Use mulle_allocator_stdlib for immediate Valgrind compatibility without code changes.
• Custom allocators that bypass libc require explicit VALGRIND_CREATE_MEMPOOL annotations to remain visible to Valgrind.
• The aba and abafree hooks support external pool management, allowing you to store pool metadata and emit Valgrind client requests during free operations.
• Default implementations reside in src/mulle-allocator.c (lines 77-99), routing all calls to standard library functions that Valgrind instruments by default.

Frequently Asked Questions

Does mulle_allocator work with Valgrind by default?

Yes. When using mulle_allocator_stdlib or the global mulle_default_allocator, all allocations route through libc malloc and free, which Valgrind intercepts automatically. Simply run your binary under Valgrind with no special compilation flags.

How do I debug custom memory pools with Valgrind?

Implement a custom struct mulle_allocator that forwards allocation requests to calloc/realloc/free, but insert Valgrind client-request macros such as VALGRIND_CREATE_MEMPOOL and VALGRIND_MEMPOOL_ALLOC before returning pointers. This creates a tracked pool while maintaining standard heap behavior.

What are the aba and abafree fields used for in Valgrind integration?

These fields enable external pool management. You can store a pool handle in the aba field and implement abafree to emit Valgrind macros like VALGRIND_DESTROY_MEMPOOL when individual blocks are freed from a custom arena, ensuring Valgrind correctly tracks pool lifecycles.

Where is the default allocator implementation located?

The default stdlib allocator is implemented in src/mulle-allocator.c, specifically in the v_calloc, v_realloc, and v_free wrappers around lines 77-99. The structure definition and global declarations are in src/mulle-allocator.h.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}