FreeRTOS heap implementations (heap_1 to heap_5) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of heap_1 malloc and free behavior

Consider FreeRTOS heap_1 implementation which provides pvPortMalloc() and vPortFree(). What is the output of the following pseudo-code snippet?

void *p1 = pvPortMalloc(100);
pvPortFree(p1);
void *p2 = pvPortMalloc(100);
if (p1 == p2) printf("Same pointer reused\n"); else printf("Different pointer\n");

Assuming heap_1 is used and memory is sufficient.

FreeRTOS

void *p1 = pvPortMalloc(100);
pvPortFree(p1);
void *p2 = pvPortMalloc(100);
if (p1 == p2) printf("Same pointer reused\n"); else printf("Different pointer\n");

A Runtime error due to double free

B Different pointer

C Compilation error due to missing free implementation

D Same pointer reused

💡 Hint

heap_1 does not implement vPortFree(), so freeing does nothing.

heap_1 provides a very simple allocator that does not actually free memory. So the pointer returned by the second malloc is the same as the first.

❓ Predict Output

intermediate

heap_4 behavior with fragmentation

Using FreeRTOS heap_4 implementation, what will be the output of this sequence?

void *p1 = pvPortMalloc(50);
void *p2 = pvPortMalloc(100);
pvPortFree(p1);
void *p3 = pvPortMalloc(40);
if (p3 == p1) printf("Reused freed block\n"); else printf("Allocated new block\n");

FreeRTOS

void *p1 = pvPortMalloc(50);
void *p2 = pvPortMalloc(100);
pvPortFree(p1);
void *p3 = pvPortMalloc(40);
if (p3 == p1) printf("Reused freed block\n"); else printf("Allocated new block\n");

A Allocated new block

B Reused freed block

C Heap corruption detected

D Memory leak warning

💡 Hint

heap_4 supports coalescing and reusing freed blocks.

heap_4 manages free blocks and will reuse the freed block if the requested size fits, so p3 equals p1.

🧠 Conceptual

advanced

Difference between heap_2 and heap_3

Which statement correctly describes the difference between FreeRTOS heap_2 and heap_3 implementations?

A heap_2 supports freeing memory but is not thread-safe; heap_3 uses standard malloc/free and is thread-safe

B heap_2 does not support freeing memory; heap_3 supports freeing memory but is not thread-safe

C heap_2 supports freeing memory and is not thread-safe; heap_3 uses standard malloc/free and is thread-safe

D heap_2 uses standard malloc/free; heap_3 is a simple bump allocator without free

💡 Hint

heap_3 wraps standard library malloc/free.

heap_2 supports freeing memory but is not thread-safe. heap_3 uses the standard malloc/free from the C library and is thread-safe if the standard library is thread-safe.

❓ Predict Output

advanced

heap_5 multi-region allocation behavior

Given heap_5 configured with two memory regions, what will be the output of this code?

void *p1 = pvPortMalloc(1024);
void *p2 = pvPortMalloc(2048);
if (p1 != NULL && p2 != NULL) printf("Both allocations succeeded\n"); else printf("Allocation failed\n");

Assume region 1 has 1024 bytes and region 2 has 2048 bytes.

FreeRTOS

void *p1 = pvPortMalloc(1024);
void *p2 = pvPortMalloc(2048);
if (p1 != NULL && p2 != NULL) printf("Both allocations succeeded\n"); else printf("Allocation failed\n");

A Both allocations succeeded

B Allocation failed

C Only second allocation succeeded

D Only first allocation succeeded

💡 Hint

heap_5 supports multiple memory regions.

heap_5 can allocate from multiple regions independently, so both allocations succeed.

❓ Predict Output

expert

heap_4 fragmentation and coalescing test

Analyze the output of this heap_4 memory allocation and free sequence:

void *p1 = pvPortMalloc(100);
void *p2 = pvPortMalloc(200);
void *p3 = pvPortMalloc(50);
pvPortFree(p2);
pvPortFree(p1);
void *p4 = pvPortMalloc(250);
if (p4 == p1) printf("Coalesced free blocks used\n"); else printf("Allocated new block\n");

FreeRTOS

void *p1 = pvPortMalloc(100);
void *p2 = pvPortMalloc(200);
void *p3 = pvPortMalloc(50);
pvPortFree(p2);
pvPortFree(p1);
void *p4 = pvPortMalloc(250);
if (p4 == p1) printf("Coalesced free blocks used\n"); else printf("Allocated new block\n");

A Coalesced free blocks used

B Allocated new block

C Heap corruption error

D Memory leak detected

💡 Hint

heap_4 merges adjacent free blocks to satisfy larger allocations.

heap_4 coalesces adjacent free blocks, so the freed blocks of 100 and 200 bytes merge to satisfy the 250-byte allocation, returning the pointer of the first freed block.

Practice

1. Which FreeRTOS heap implementation does NOT support freeing allocated memory?

easy

A. heap_1

B. heap_2

C. heap_3

D. heap_4

Solution

1. Step 1: Understand heap_1 behavior

   heap_1 only allows allocation but does not provide a function to free memory once allocated.

2. Step 2: Compare with other heaps

   heap_2, heap_3, and heap_4 all support freeing memory, with heap_3 using standard malloc/free.

3. Final Answer:

   heap_1 -> Option A

4. Quick Check:

   heap_1 no free support = heap_1 [OK]

Hint: heap_1 never frees memory, others do [OK]

Common Mistakes:

• Confusing heap_1 with heap_2 which supports free
• Assuming all heaps support freeing memory
• Mixing heap_3's malloc/free with heap_1's behavior

2. Which of the following is the correct way to include the heap_3 implementation in your FreeRTOS project?

easy

A. #include "heap3.c"

B. #include "heap_3.c"

C. #include "FreeRTOSHeap3.c"

D. #include

Solution

1. Step 1: Check FreeRTOS heap file naming

   Heap implementations are included by adding the corresponding .c file, e.g., "heap_3.c".

2. Step 2: Verify correct syntax

   Using #include "heap_3.c" is the standard way to include heap_3 in the build.

3. Final Answer:

   #include "heap_3.c" -> Option B

4. Quick Check:

   Include heap_3.c with quotes = D [OK]

Hint: Include heap source file with quotes, not angle brackets [OK]

Common Mistakes:

• Using angle brackets instead of quotes
• Incorrect file name spelling or casing
• Trying to include a header instead of the .c file

3. Given the following code snippet using heap_4, what will be the output if the allocation fails?

void *ptr = pvPortMalloc(1000);
if(ptr == NULL) {
    printf("Allocation failed\n");
} else {
    printf("Allocation succeeded\n");
}

medium

A. Compilation error

B. Allocation succeeded

C. Allocation failed

D. No output

Solution

1. Step 1: Understand heap_4 allocation behavior

   heap_4 supports allocation and freeing with coalescing. If memory is insufficient, pvPortMalloc returns NULL.

2. Step 2: Analyze the if condition

   If ptr is NULL, the code prints "Allocation failed"; otherwise, it prints "Allocation succeeded".

3. Final Answer:

   Allocation failed -> Option C

4. Quick Check:

   pvPortMalloc NULL means failure = A [OK]

Hint: pvPortMalloc returns NULL on failure [OK]

Common Mistakes:

• Assuming allocation always succeeds
• Confusing NULL with zero pointer
• Ignoring the if condition logic

4. You are using heap_2 in your FreeRTOS project but notice memory is not being freed properly. Which of the following is the most likely cause?

medium

A. heap_2 does not support freeing memory

B. heap_2 uses standard malloc/free which is not thread-safe

C. heap_2 requires manual coalescing of free blocks

D. You forgot to call vPortFree() after allocation

Solution

1. Step 1: Recall heap_2 features

   heap_2 supports freeing memory via vPortFree(), but does not coalesce free blocks.

2. Step 2: Identify common mistake

   If memory is not freed, the most common cause is forgetting to call vPortFree() after allocation.

3. Final Answer:

   You forgot to call vPortFree() after allocation -> Option D

4. Quick Check:

   Missing vPortFree causes leaks = B [OK]

Hint: Always call vPortFree() to release heap_2 memory [OK]

Common Mistakes:

• Assuming heap_2 lacks free support
• Confusing heap_2 with heap_1 or heap_3
• Thinking heap_2 uses malloc/free internally

5. You want to use a FreeRTOS heap implementation that supports both allocation and freeing, minimizes fragmentation by coalescing adjacent free blocks, and is suitable for real-time systems. Which heap should you choose?

hard

A. heap_4

B. heap_2

C. heap_1

D. heap_5

Solution

1. Step 1: Review heap features

   heap_1 does not support freeing; heap_2 supports free but no coalescing; heap_4 supports free and coalesces adjacent free blocks; heap_5 extends heap_4 with multiple memory regions.

2. Step 2: Match requirements

   For minimizing fragmentation and real-time suitability, heap_4 is ideal as it coalesces free blocks and is deterministic.

3. Final Answer:

   heap_4 -> Option A

4. Quick Check:

   heap_4 coalesces free blocks = A [OK]

Hint: heap_4 coalesces free blocks, best for fragmentation [OK]

Common Mistakes:

• Choosing heap_5 without needing multiple regions
• Assuming heap_2 coalesces free blocks
• Picking heap_1 which lacks free support