Mini Malloc Memory Management System

🏗️ Architecture Overview

This mini malloc implementation uses a multi-arena system to reduce lock contention in multi-threaded environments.

Arena 0

Block 1 (64B)

Block 2 (128B)

Block 3 (32B)

Arena 1

Block 1 (256B)

Block 2 (64B)

Arena 2

Block 1 (512B)

Arena 3

MMAP Block (128KB)

Used Block (sbrk)

Free Block

MMAP Block (≥64KB)

🧵 Thread to Arena Mapping

Thread 1

ID: 12345

Arena: 12345 % 8 = 1

Thread 2

ID: 67890

Arena: 67890 % 8 = 2

Thread 3

ID: 54321

Arena: 54321 % 8 = 1

📊 Function Workflows

malloc(size_t size) Flow

Size Alignment: Round up size to 8-byte boundary
size = ALIGN8(size)

Arena Selection: Get arena based on thread ID
arena_idx = pthread_self() % NUM_ARENAS

Size Check: If size ≥ 64KB, use mmap directly
if (size >= MMAP_THRESHOLD) goto mmap_path

Search Free Blocks: First-fit search in arena
find_free_block(&last, size, arena)

Block Found: Split if necessary, mark as used
No Block: Request new space via sbrk()

free(void *ptr) Flow

Get Block Metadata: ptr - sizeof(block_meta)
block_meta *b = (block_meta *)ptr - 1

Validate Block: Check if block is valid

MMAP Check: If mmap block, unmap directly
if (b->use_mmap) munmap(b, total_size)

Mark Free: Set free flag and coalesce
b->free = 1; coalesce(b)

realloc(void *ptr, size_t size) Flow

Edge Cases:
• If ptr == NULL → malloc(size)
• If size == 0 → free(ptr), return NULL

Same Size or Smaller: If current size ≥ new size
Split block if beneficial, return same pointer

Try In-Place Expansion: Check if next block is free
Coalesce and reuse if total size is sufficient

Fallback: malloc(new_size) + memcpy + free(old)

calloc(size_t nmemb, size_t size) Flow

Overflow Check: Detect integer overflow
__builtin_mul_overflow(nmemb, size, &total)

Allocate: Call malloc(total_size)

Zero Memory: memset(ptr, 0, total_size)

🎮 Interactive Simulation

🧵 Current Thread Info

Active Thread: 1
Target Arena: 1
Arena Calculation: 1 % 8 = 1

📝 Operation Log

System initialized with 8 arenas...

📊 Statistics

Total Allocations: 0

Active Blocks: 0

Free Blocks: 0

MMAP Blocks: 0

Total Memory: 0 bytes

Fragmentation: 0%

🗺️ Memory Layout

📚 Stack

Thread stacks, local variables, function calls

🗺️ MMAP Region

Large allocations (≥64KB), memory-mapped files, libraries

🏗️ Heap (sbrk)

Arena-managed blocks, small-medium allocations (<64KB)

🔧 Block Structure

                        Block Metadata (32 bytes)

                        • size_t size (8 bytes)

                        • block_meta *next (8 bytes)

                        • block_meta *prev (8 bytes)

                        • uint8_t free (1 byte)

                        • uint8_t use_mmap (1 byte)

                        • uint8_t arena_idx (1 byte)

                        • padding (5 bytes)
                    
                        User Payload

                        Available memory returned to user

🧵 Multi-Threading Benefits

Arena Striping: Each thread is assigned to an arena based on thread ID modulo number of arenas (8).

Reduced Lock Contention: Threads in different arenas can allocate/free simultaneously.

Cache Locality: Related allocations from the same thread are likely in the same arena.

MMAP Bypass: Large allocations (≥64KB) bypass arena system entirely for better performance.