FreeRTOS heap implementations (heap_1 to heap_5) - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main characteristic of the heap_1 memory allocator in FreeRTOS?

heap_1 is the simplest allocator. It only allows memory allocation and does not support freeing memory. It is useful for very simple applications where memory is allocated once and never freed.

beginner

How does heap_2 differ from heap_1 in FreeRTOS?

heap_2 supports both memory allocation and freeing. It uses a simple algorithm to manage free blocks but does not coalesce adjacent free blocks, which can lead to fragmentation over time.

beginner

What feature does heap_3 add compared to heap_2 in FreeRTOS?

heap_3 wraps the standard C library malloc() and free() functions. It relies on the system's heap management, making it easy to use but dependent on the underlying C library implementation.

intermediate

Describe the key advantage of heap_4 in FreeRTOS.

heap_4 supports allocation, freeing, and also coalesces adjacent free blocks to reduce fragmentation. It uses a best-fit algorithm to manage memory efficiently, making it suitable for applications needing dynamic memory management.

intermediate

What unique feature does heap_5 provide in FreeRTOS?

heap_5 allows the heap to be split into multiple non-contiguous memory regions. This is useful for systems with fragmented memory or multiple memory banks. It also supports allocation, freeing, and coalescing like heap_4.

Which FreeRTOS heap implementation does NOT support freeing memory?

A heap_2

B heap_4

C heap_3

D heap_1

heap_1 only supports allocation and does not allow freeing memory.

Which heap implementation uses the standard C library malloc() and free()?

A heap_3

B heap_5

C heap_4

D heap_2

heap_3 wraps the standard C library malloc() and free() functions.

What is the main benefit of heap_4 over heap_2?

A Supports multiple memory regions

B Uses standard C malloc()

C Coalesces adjacent free blocks to reduce fragmentation

D Does not support freeing memory

heap_4 coalesces adjacent free blocks, reducing fragmentation compared to heap_2.

Which heap implementation allows splitting the heap into multiple non-contiguous memory regions?

A heap_3

B heap_5

C heap_4

D heap_1

heap_5 supports multiple non-contiguous memory regions.

If you want a simple allocator with no free support, which heap should you choose?

A heap_1

B heap_2

C heap_4

D heap_5

heap_1 is the simplest allocator and does not support freeing memory.

Explain the differences between heap_1, heap_2, and heap_4 in FreeRTOS.

Think about how each handles freeing memory and fragmentation.

Describe when you would use heap_5 in a FreeRTOS application.

Consider systems with multiple memory banks or fragmented RAM.

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