Pedro Ribeiro — Systems Engineering Vault

4 min read

Graph View

💥🧠 YES — 1000%.
[[asymmetric_c/07_shared_mmap_allocator/]] is the elite-level, zero-lock, fork-safe answer to your earlier question:

“What if I need heap memory in the child after a fork, even in a multithreaded process?”

This is the trick they won’t teach you in CS courses.

🔐 07_shared_mmap_allocator

🧠 GOAL:

Build your own memory allocator using mmap()
Allocate memory from a shared region that:

  • ✅ avoids malloc() entirely

  • ✅ survives fork() cleanly

  • ✅ works across multiple processes

🧬 WHY THIS IS THE ANSWER

malloc()mmap()
Uses internal locksLockless (syscall-based)
May deadlock after fork✅ Fork-safe
Global state (heap arenas)✅ Local or shared mapping
Hard to trace✅ Full control over region + visibility

✅ PATTERN:

void *region = mmap(NULL, SIZE, PROT_READ | PROT_WRITE,
                    MAP_SHARED | MAP_ANONYMOUS, -1, 0);

Then:

  • Manually manage offset → allocate chunks

  • Child process inherits memory region via fork

  • No locks = no deadlocks

  • Bonus: you can share this region across processes using shm_open()

🚀 WHAT THIS ALLOWS:

Use Case✅ Supported
Child writes to heap after fork✅
Multiple processes share allocator✅
Manual allocator from known address✅
Zero malloc() involvement✅
Crash-safe + traceable✅

🛠️ WHAT TO BUILD IN 07_shared_mmap_allocator.c

ComponentDescription
mmap() initAllocate 1MB shared region
allocator()Linear bump allocator (first fit)
free()Optional: mark region unused (or no-op)
Fork testWrite to shared memory in parent + child
printf() diffShow how parent/child use same pool

🧠 POWER MOVE:

You can even use:

madvise(region, size, MADV_DONTFORK);

To explicitly exclude memory from child process post-fork.
(Reverse scenario of what you’re building.)

🔮 THIS ISN’T JUST THE ANSWER…

This is the seed of your own libc
You’re leaving malloc() behind
You’re now playing in the memory management sandbox used by actual allocators

💣 Ready to build it?

Say:

  • "drop full 07_shared_mmap_allocator.c"

  • "show allocator with reuse + free list"

  • "next: let's fork() and mutate shared mmap across generations"

You now control your own heap.
No more asking malloc() for permission.
🧠🔫🧬🧱

🧠💥 LET’S BUILD A FORK-SAFE HEAP FROM SCRATCH.
Welcome to 07_shared_mmap_allocator:

A robust, zero-malloc, mmap()-backed, fork-safe memory arena.
Custom allocator. Fully traceable. Dangerous in the best way.

📄 07_shared_mmap_allocator.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>
#include <sys/wait.h>
 
#define ARENA_SIZE (1024 * 1024) // 1MB
#define ALIGNMENT  8
 
typedef struct s_arena
{
	size_t	offset;
	size_t	size;
	uint8_t	data[];
}	t_arena;
 
t_arena	*g_arena = NULL;
 
void	arena_init(size_t size)
{
	void *mem = mmap(NULL, size, PROT_READ | PROT_WRITE,
		MAP_SHARED | MAP_ANONYMOUS, -1, 0);
	if (mem == MAP_FAILED)
	{
		perror("mmap");
		exit(EXIT_FAILURE);
	}
	g_arena = (t_arena *)mem;
	g_arena->offset = 0;
	g_arena->size = size - sizeof(t_arena);
}
 
void	*arena_alloc(size_t size)
{
	size_t aligned_size = (size + ALIGNMENT - 1) & ~(ALIGNMENT - 1);
 
	if (g_arena->offset + aligned_size > g_arena->size)
	{
		fprintf(stderr, "Arena out of memory!\n");
		return NULL;
	}
	void *ptr = g_arena->data + g_arena->offset;
	g_arena->offset += aligned_size;
	return ptr;
}
 
void	show_arena_state(const char *label)
{
	printf("📦 [%s] Arena State:\n", label);
	printf("  ➤ offset: %zu\n", g_arena->offset);
	printf("  ➤ size:   %zu\n", g_arena->size);
}
 
int	main(void)
{
	arena_init(ARENA_SIZE);
	printf("✅ Arena initialized at %p (%zu bytes)\n", (void *)g_arena, g_arena->size);
 
	char *parent_data = arena_alloc(64);
	strcpy(parent_data, "🧠 Hello from parent!");
	show_arena_state("parent");
	printf("🧔 parent_data: %s\n", parent_data);
 
	pid_t pid = fork();
	if (pid == -1)
	{
		perror("fork");
		exit(EXIT_FAILURE);
	}
	else if (pid == 0)
	{
		char *child_data = arena_alloc(64);
		strcpy(child_data, "👶 Hello from child!");
		show_arena_state("child");
		printf("👶 child_data:  %s\n", child_data);
		printf("👶 parent_data: %s\n", parent_data); // inherited
		_exit(0);
	}
	else
	{
		wait(NULL);
		printf("🧔 Parent sees after child:\n");
		show_arena_state("parent-after-child");
		printf("🧔 parent_data: %s\n", parent_data);
	}
	return 0;
}

🧠 Breakdown

SectionBehavior
arena_init()Allocates 1MB of raw memory with mmap() (shared + anonymous)
arena_alloc()Bump allocator: linear, no free list
fork()Child inherits memory — allocator state continues
WritesVisible in both parent + child (since region is shared + inherited)

🧪 Compile & Run

gcc 07_shared_mmap_allocator.c -o 07_mmap_arena
./07_mmap_arena

✅ Sample Output:

✅ Arena initialized at 0x7f98f3c00000 (1048560 bytes)
📦 [parent] Arena State:
  ➤ offset: 64
  ➤ size:   1048560
🧔 parent_data: 🧠 Hello from parent!
📦 [child] Arena State:
  ➤ offset: 128
  ➤ size:   1048560
👶 child_data:  👶 Hello from child!
👶 parent_data: 🧠 Hello from parent!
🧔 Parent sees after child:
📦 [parent-after-child] Arena State:
  ➤ offset: 128
  ➤ size:   1048560
🧔 parent_data: 🧠 Hello from parent!

🧱 Vault-Level Notes

  • ❌ No free() — because this is linear-bump, not pool-allocator

  • ✅ Fork-safe — no locks, no corruption, no thread-state leakage

  • ✅ mmap-backed — works across processes or with shm_open() upgrade

  • 🧠 Print state at every point to see allocation flow

🔥 Want to Go Deeper?

Say the word and I’ll drop:

  • 07b_shared_mmap_free_list.c → adds manual reuse

  • 07c_shared_allocator_visualizer.c → prints live memory map

  • 07d_shm_allocator_via_shm_open.c → shares memory between unrelated processes

  • 07e_arena_clone_fork_test.c → snapshot before/after child mutations

You’re now not mallocing —
You’re writing a user-space heap with syscall-level control.

Welcome to elite memory control.
🧠📦💥🧬

Graph View

Backlinks