Memory pool (fixed-size block allocator) in Embedded C - Mini Project: Build & Apply

Memory Pool (Fixed-Size Block Allocator)

📖 Scenario: In embedded systems, memory is limited and dynamic allocation can be risky. A memory pool helps by pre-allocating fixed-size blocks of memory to manage resources efficiently and safely.Imagine you are building a small device that needs to allocate and free memory blocks quickly without fragmentation.

🎯 Goal: You will build a simple fixed-size memory pool allocator in C. It will allow allocating and freeing blocks of memory from a pre-allocated pool.This helps manage memory safely in embedded systems.

📋 What You'll Learn

Create a fixed-size memory pool array

Create a free list to track available blocks

Implement an allocate function to get a free block

Implement a free function to return a block to the pool

Print the status of the pool after allocations and frees

💡 Why This Matters

🌍 Real World

Fixed-size memory pools are used in embedded systems, real-time systems, and games to manage memory efficiently without fragmentation.

💼 Career

Understanding memory pools helps embedded developers write safer, faster code with predictable memory usage, a key skill in firmware and low-level programming jobs.

1

Create the memory pool array

Create a char array called memory_pool with size 128 to represent the fixed-size memory pool.

Embedded C

# Create a char array called memory_pool with size 128
# Your code here

Need a hint?

Think of memory_pool as a box with 128 small slots to store data.

2

Create the free list array

Create an int array called free_list with size 16 to track free blocks. Also create an int variable called free_count and set it to 16.

Embedded C

char memory_pool[128];
# Create an int array called free_list with size 16
# Create an int variable free_count and set it to 16
# Your code here

Need a hint?

Each block is 8 bytes (128 / 16), so free_list tracks which blocks are free.

3

Initialize the free list

Write a for loop using int i from 0 to 15 to fill free_list with block indexes from 0 to 15.

Embedded C

char memory_pool[128];
int free_list[16];
int free_count = 16;

# Use a for loop with int i from 0 to 15 to fill free_list with values 0 to 15
# Your code here

Need a hint?

This sets all blocks as free initially.

4

Implement allocate and free functions and print status

Implement two functions: void* allocate() that returns a pointer to a free 8-byte block or NULL if none free, and void free_block(void* ptr) that returns a block to the free list. Then, allocate three blocks, free the second, and print the indexes of free blocks separated by spaces using printf.

Embedded C

char memory_pool[128];
int free_list[16];
int free_count = 16;

for (int i = 0; i < 16; i++) {
    free_list[i] = i;
}

// Implement allocate and free_block functions
// Allocate three blocks, free the second
// Print free block indexes separated by spaces
// Your code here

Need a hint?

Remember to decrease free_count when allocating and increase it when freeing.

Printing free_list shows which blocks are free.