malloc_freertos.c File Reference

#include <assert.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <malloc.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>

Include dependency graph for malloc_freertos.c:

Go to the source code of this file.

Macros
#define	FREERTOS_HEAP_REGION_CNT   2

Functions
static int	cmp_heap (const void *a, const void *b)
void	malloc_addblock (void *addr, size_t size)
	Assign blocks of memory for use by malloc(). More...
	__attribute__ ((weak))
void *	malloc (size_t size)
void	free (void *ptr)

Variables
static const uint8_t	heap_region_max = FREERTOS_HEAP_REGION_CNT
	Maximum number of heap regions that can be specified. More...
static volatile uint8_t	heap_region_cnt = 0
	Current number of allocated heap regions. More...
static HeapRegion_t	heap_regions [FREERTOS_HEAP_REGION_CNT+1]
static volatile bool	initialized_ = false

Macro Definition Documentation

FREERTOS_HEAP_REGION_CNT

#define FREERTOS_HEAP_REGION_CNT   2

NOTE: This FreeRTOS malloc implementation requires heap_5.c

Please define the correct heap_region for your project.Your application can define this macro to increase the number of heap regions

Definition at line 26 of file malloc_freertos.c.

Function Documentation

__attribute__()

__attribute__

(

(weak)

)

Definition at line 90 of file malloc_freertos.c.

{
    assert((heap_region_cnt > 0) && !initialized_);

    if(heap_region_cnt > 0 && !initialized_)
    {
        // Sort the heap regions so addresses are in the correct order
        qsort(heap_regions, heap_region_cnt, sizeof(HeapRegion_t), cmp_heap);

        // Pass the array into vPortDefineHeapRegions() to enable malloc()
        vPortDefineHeapRegions(heap_regions);

        // Signal to any waiting threads that we are done initializing
        initialized_ = true;
    }
}

References cmp_heap(), heap_region_cnt, heap_regions, and initialized_.

cmp_heap()

static int cmp_heap ( const void *  a, const void *  b  )

static

Definition at line 54 of file malloc_freertos.c.

{
    const HeapRegion_t* ua = a;
    const HeapRegion_t* ub = b;

    return ((ua->pucStartAddress < ub->pucStartAddress)
                ? -1
                : ((ua->pucStartAddress != ub->pucStartAddress)));
}

Referenced by __attribute__().

free()

void free

(

void *

ptr

)

free should NEVER be called before malloc is init'd

Definition at line 126 of file malloc_freertos.c.

{
    assert(initialized_);

    if(ptr)
    {
        // We simply wrap the FreeRTOS call into a standard form
        vPortFree(ptr);
    }
}

References initialized_.

malloc()

void* malloc

(

size_t

size

)

Definition at line 107 of file malloc_freertos.c.

{
    void* ptr = NULL;

    while(!initialized_)
    {
        // Thread blocks until application malloc has been correctly initialized
        vTaskDelay(1);
    }

    if(size > 0)
    {
        // We simply wrap the FreeRTOS call into a standard form
        ptr = pvPortMalloc(size);
    } // else NULL if there was an error

    return ptr;
}

References initialized_.

malloc_addblock()

void malloc_addblock	(	void *	addr,
		size_t	size
	)

Assign blocks of memory for use by malloc().

malloc_addblock must be called before memory allocation calls are made. In this FreeRTOS implementation, malloc() calls will block until memory has been allocated

Definition at line 69 of file malloc_freertos.c.

{
    assert(addr && (size > 0));
    assert((heap_region_cnt < heap_region_max) && "Too many heap regions!");

    // Increment the count early to claim a spot in case of multi-threads
    uint8_t cnt = heap_region_cnt++;

    if(cnt < heap_region_max)
    {
        // We have space - add it to the table
        heap_regions[cnt].pucStartAddress = (uint8_t*)addr;
        heap_regions[cnt].xSizeInBytes = size;
    }
    else
    {
        // Decrement the count if we don't have space
        heap_region_cnt--;
    }
}

References heap_region_cnt, heap_region_max, and heap_regions.

Variable Documentation

heap_region_cnt

volatile uint8_t heap_region_cnt = 0

static

Current number of allocated heap regions.

Definition at line 35 of file malloc_freertos.c.

Referenced by __attribute__(), and malloc_addblock().

heap_region_max

const uint8_t heap_region_max = FREERTOS_HEAP_REGION_CNT

static

Maximum number of heap regions that can be specified.

Definition at line 32 of file malloc_freertos.c.

Referenced by malloc_addblock().

heap_regions

HeapRegion_t heap_regions[FREERTOS_HEAP_REGION_CNT+1]

static

FreeRTOS internal memory pool stucture when using heap_5.c

The block with the lowest starting address should appear first in the array

An additional block is allocated to serve as a NULL terminator

Definition at line 44 of file malloc_freertos.c.

Referenced by __attribute__(), and malloc_addblock().

initialized_

volatile bool initialized_ = false

static

Flag that is used in malloc() to cause competing threads to wait until initialization is completed before allocating memory.

Definition at line 50 of file malloc_freertos.c.

Referenced by __attribute__(), free(), and malloc().