Memory pool (fixed-size block allocator) in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of memory pool initialization

What is the output of this code snippet that initializes a fixed-size block memory pool and prints the number of free blocks?

Embedded C

#include <stdio.h>
#include <stdint.h>

#define BLOCK_SIZE 16
#define POOL_SIZE 64

uint8_t pool[POOL_SIZE * BLOCK_SIZE];
uint8_t free_list[POOL_SIZE];

int free_count = 0;

void mempool_init() {
    for (int i = 0; i < POOL_SIZE; i++) {
        free_list[i] = 1; // mark all blocks free
    }
    free_count = POOL_SIZE;
}

int main() {
    mempool_init();
    printf("Free blocks: %d\n", free_count);
    return 0;
}

A Free blocks: 0

B Free blocks: 64

C Free blocks: 16

D Free blocks: 1

💡 Hint

Look at how free_count is set during initialization.

The mempool_init function marks all 64 blocks as free and sets free_count to 64. So the output prints 'Free blocks: 64'.

❓ Predict Output

intermediate

Output after allocating two blocks

Given this memory pool code, what is the output after allocating two blocks and printing the free count?

Embedded C

#include <stdio.h>
#include <stdint.h>

#define BLOCK_SIZE 8
#define POOL_SIZE 4

uint8_t pool[POOL_SIZE * BLOCK_SIZE];
uint8_t free_list[POOL_SIZE];

int free_count = 0;

void mempool_init() {
    for (int i = 0; i < POOL_SIZE; i++) {
        free_list[i] = 1;
    }
    free_count = POOL_SIZE;
}

void* mempool_alloc() {
    for (int i = 0; i < POOL_SIZE; i++) {
        if (free_list[i]) {
            free_list[i] = 0;
            free_count--;
            return &pool[i * BLOCK_SIZE];
        }
    }
    return NULL;
}

int main() {
    mempool_init();
    mempool_alloc();
    mempool_alloc();
    printf("Free blocks: %d\n", free_count);
    return 0;
}

A Free blocks: 0

B Free blocks: 4

C Free blocks: 2

D Free blocks: 3

💡 Hint

Each allocation reduces free_count by one.

Initially, free_count is 4. After two allocations, free_count decreases by 2, resulting in 2 free blocks left.

🔧 Debug

advanced

Identify the bug causing double free

This memory pool code allows freeing blocks. What bug causes a double free error when freeing the same block twice?

Embedded C

#include <stdio.h>
#include <stdint.h>

#define BLOCK_SIZE 8
#define POOL_SIZE 2

uint8_t pool[POOL_SIZE * BLOCK_SIZE];
uint8_t free_list[POOL_SIZE];

int free_count = 0;

void mempool_init() {
    for (int i = 0; i < POOL_SIZE; i++) {
        free_list[i] = 1;
    }
    free_count = POOL_SIZE;
}

void* mempool_alloc() {
    for (int i = 0; i < POOL_SIZE; i++) {
        if (free_list[i]) {
            free_list[i] = 0;
            free_count--;
            return &pool[i * BLOCK_SIZE];
        }
    }
    return NULL;
}

void mempool_free(void* ptr) {
    int index = ((uint8_t*)ptr - pool) / BLOCK_SIZE;
    free_list[index] = 1;
    free_count++;
}

int main() {
    mempool_init();
    void* p = mempool_alloc();
    mempool_free(p);
    mempool_free(p); // double free
    printf("Free blocks: %d\n", free_count);
    return 0;
}

A No check if block is already free before freeing it

B free_count is not incremented on free

C Index calculation is incorrect causing out-of-bounds access

D Memory pool is not initialized before use

💡 Hint

Think about what happens if you free the same block twice.

The mempool_free function does not check if the block is already free. Freeing the same block twice increments free_count twice and marks the block free twice, causing double free issues.

📝 Syntax

advanced

Identify the syntax error in memory pool allocation

Which option contains the syntax error in this memory pool allocation function?

Embedded C

void* mempool_alloc() {
    for (int i = 0; i < POOL_SIZE; i++) {
        if (free_list[i]) {
            free_list[i] = 0;
            free_count--;
            return &pool[i * BLOCK_SIZE];
        }
    }
    return NULL;
}

A Using &pool[i * BLOCK_SIZE] instead of pool + i * BLOCK_SIZE

B Incorrect return type void* instead of int*

C POOL_SIZE is not defined

D Missing semicolon after free_list[i] = 0

💡 Hint

Look carefully at each line inside the for loop.

The line 'free_list[i] = 0' is missing a semicolon, causing a syntax error.

🚀 Application

expert

Calculate maximum allocatable blocks after mixed operations

Given a memory pool with 10 blocks, after allocating 4 blocks, freeing 2 of them, and allocating 3 more, how many blocks remain free?

Embedded C

#define POOL_SIZE 10

// Initially all blocks free
// Allocate 4 blocks
// Free 2 blocks
// Allocate 3 blocks

// How many free blocks remain?

A 5

B 3

C 4

D 6

💡 Hint

Track allocations and frees step by step.

Start with 10 free blocks. Allocate 4 → free blocks = 6 Free 2 → free blocks = 8 Allocate 3 → free blocks = 5 So, 5 blocks remain free.