Project 6: Dynamic Memory Allocator

A custom memory allocator with multiple strategies (first-fit, best-fit, buddy system), debugging features, and leak detection.

Quick Reference

Attribute Value
Primary Language C
Alternative Languages Rust (for comparison)
Difficulty Level 4 - Expert
Time Estimate See main guide
Knowledge Area Memory Management, Systems Programming
Tooling GCC, Valgrind, AddressSanitizer
Prerequisites See main guide

What You Will Build

A custom memory allocator with multiple strategies (first-fit, best-fit, buddy system), debugging features, and leak detection.

Why It Matters

This project builds core skills that appear repeatedly in real-world systems and tooling.

Core Challenges

  • Free list management → Maps to understanding heap organization
  • Coalescing freed blocks → Maps to fragmentation prevention
  • Memory debugging → Maps to leak and corruption detection

Key Concepts

  • Map the project to core concepts before you code.

Real-World Outcome

# 1. Basic allocation test
$ ./mem_test basic
MyAlloc initialized with 1MB heap
Allocated 100 bytes at 0x7f8b1000 (block size: 112)
Allocated 200 bytes at 0x7f8b1070 (block size: 208)
Freed 0x7f8b1000
Allocated 50 bytes at 0x7f8b1000 (reused freed block!)
All allocations freed. Heap clean.

# 2. Leak detection
$ ./mem_test leak
MyAlloc: Creating 5 allocations...
MyAlloc: Freeing only 3...
MyAlloc: Simulating program exit...

=== MEMORY LEAK REPORT ===
Leaked block at 0x7f8b1200: 256 bytes
  Allocated at: test.c:42 in function test_leak()
Leaked block at 0x7f8b1400: 128 bytes
  Allocated at: test.c:43 in function test_leak()
Total leaked: 384 bytes in 2 blocks

# 3. Double-free detection
$ ./mem_test double_free
Allocated at 0x7f8b1000
First free: OK
Second free: FATAL ERROR: Double free detected at 0x7f8b1000
  Originally allocated at: test.c:50
  First freed at: test.c:51
  Double-free attempted at: test.c:52

# 4. Strategy comparison
$ ./mem_test benchmark
Running 10000 allocations/frees...

Strategy        | Time    | Fragmentation | Peak Memory
----------------|---------|---------------|-------------
First-Fit       | 45ms    | 23%           | 1.8MB
Best-Fit        | 120ms   | 8%            | 1.2MB
Buddy System    | 35ms    | 31%           | 2.1MB

Implementation Guide

  1. Reproduce the simplest happy-path scenario.
  2. Build the smallest working version of the core feature.
  3. Add input validation and error handling.
  4. Add instrumentation/logging to confirm behavior.
  5. Refactor into clean modules with tests.

Milestones

  • Milestone 1: Minimal working program that runs end-to-end.
  • Milestone 2: Correct outputs for typical inputs.
  • Milestone 3: Robust handling of edge cases.
  • Milestone 4: Clean structure and documented usage.

Validation Checklist

  • Output matches the real-world outcome example
  • Handles invalid inputs safely
  • Provides clear errors and exit codes
  • Repeatable results across runs

References

  • Main guide: PROFESSIONAL_C_PROGRAMMING_MASTERY.md
  • Effective C, 2nd Edition by Robert C. Seacord