Example of a Real-Time Operating System: FreeRTOS

Size: px

Start display at page:

Download "Example of a Real-Time Operating System: FreeRTOS"

Oswin Long
5 years ago
Views:

1 Example of a Real-Time Operating System: FreeRTOS

2 1. Background of FreeRTOS

3 FreeRTOS Supported architectures and license model Real-time operating system (kernel) from Real Time Engineers Ltd. (London, UK) Current version: V9.0.0 Runs on many different ISA (instruction set architecture) platforms as, e.g., ARM x86 (IA-32, Intel 64) MicroBlaze (soft microprocessor that is implemented on FPGAs) Microcontroller: (MCU = microcontroller unit): CPU + Memory + I/O PIC microcontroller Renesas H8 Atmel AVR and many more License model: GPL (Gnu General Public License) with important exception allows user code to be closed source, while Kernel code has to be distributed as open source [1] XXX Slide 3 / TOC 6/20/2018 5:29:55 PM

4 FreeRTOS Distribution of FreeRTOS According to the 2015 UBM Embedded Market Study FreeRTOS is at the top position. Market share: FreeRTOS: 22% VxWorks: 6% QNX: 4% ecos: 2% [1] XXX [1] XXX Slide 4 / TOC 6/20/2018 5:29:56 PM

FreeRTOS Some history The man behind FreeRTOS: Richard Barry Worked within a consulting project that tried to replace an existing RTOS solution with another to avoid the need of license fees But

5 FreeRTOS Some history The man behind FreeRTOS: Richard Barry Worked within a consulting project that tried to replace an existing RTOS solution with another to avoid the need of license fees But there were no good simple and small alternatives Richard Barry identified this gap in the market Idea of FreeRTOS was born [1] [1] Slide 5 / TOC 6/20/2018 5:29:56 PM

6 2. FreeRTOS design philosophy

7 FreeRTOS A free small Micro-Kernel Small & simple (micro-kernel) approach: only some few kernel.h files; a so called header-only-library written in C & some assembly code (for architecture specific scheduler routines); very well documented according to my opinion for sure also a reason for its success Kernel supports Multi-Threading with thread priorities Mutexes & Semaphores Scheduler can be configured for preemptive or cooperative operation Trace support for recording & visualizing the runtime behavior of a FreeRTOS system 4 different memory allocation schemes: Allocate only Allocate + free with a simple fast algorithm Allocate + free with a more complex memory coalescence algorithm C style memalloc() and free() No support for: user accounts / rights management device drivers file systems [1] Are header-only libraries more efficient? [2] Benefits of header-only libraries Slide 7 / TOC 6/20/2018 5:29:56 PM

companies) [1] Screenshot of http://www.freertos.

8 FreeRTOS Additional OS system components are available as add-ons (partly from other companies) [1] Screenshot of Slide 8 / TOC 6/20/2018 5:29:56 PM

9 FreeRTOS Supported platforms for FreeRTOS are called ports in the FreeRTOS terminology [1] FreeRTOS Ports Slide 9 / TOC 6/20/2018 5:29:56 PM

10 FreeRTOS How does the Windows simulator port work? From FreeRTOS windows port simulator description website: Principle of Operation: Threads that run tasks The Windows port layer creates a low priority Windows thread for each FreeRTOS task created by the FreeRTOS application. All the low priority Windows threads are then kept in the suspended state, other than the Windows thread that is running the FreeRTOS task selected by the FreeRTOS scheduler to be in the Running state. In this way, the FreeRTOS scheduler chooses which low priority Windows thread to run in accordance with its scheduling policy. All the other low priority windows threads cannot run because they are suspended. FreeRTOS ports that run on microcontrollers have to perform complex context switching to save and restore the microcontroller context (registers, etc.) as tasks enter and leave the Running state. In contrast, the Windows simulator layer simply has to suspend and resume Windows threads as the tasks they represent enter and leave the Running state. The real context switching is left to Windows. [1] Windows-Thread Windows-Thread Windows-Thread (suspended) Windows-Thread with FreeRTOS task1 (suspended) Windows-Thread with FreeRTOS task2 (suspended) [1] FreeRTOS Windows Port simulator Windows-Thread with FreeRTOS task3 (running) Windows-Thread with FreeRTOS task4 (suspended) Windows-Thread FreeRTOS scheduler (running) Threads to be scheduled by the Windows scheduler Slide 10 / TOC 6/20/2018 5:29:56 PM

11 3. A first simple FreeRTOS code example

FreeRTOS Introduction to the simple example Example creates two tasks and a software timer that communicate with the help of a message queue Sender task is generated periodically with period time =

12 FreeRTOS Introduction to the simple example Example creates two tasks and a software timer that communicate with the help of a message queue Sender task is generated periodically with period time = 200ms; writes value 100 to queue Timer shoots 2000ms after keypress, writes value 200 to queue Receiver task gets activated whenever there is something new in the queue to read Sender Task Software Timer Message Queue Receive Task Slide 12 / TOC 6/20/2018 5:29:57 PM

13 FreeRTOS Code example: creating two tasks, a timer, and starting the task scheduler void main_blinky( void ) { const TickType_t xtimerperiod = maintimer_send_frequency_ms; /* Create the queue. */ xqueue = xqueuecreate( mainqueue_length, sizeof( uint32_t ) ); if( xqueue!= NULL ) { /* Start the two tasks as described in the comments at the top of this file. */ xtaskcreate( prvqueuereceivetask, /* The function that implements the task. */ "Rx", /* The text name assigned to the task - for debug only as it is not used by the kernel. */ configminimal_stack_size, /* The size of the stack to allocate to the task. */ NULL, /* The parameter passed to the task - not used in this simple case. */ mainqueue_receive_task_priority, /* The priority assigned to the task. */ NULL ); /* The task handle is not required, so NULL is passed. */ xtaskcreate( prvqueuesendtask, "TX", configminimal_stack_size, NULL, mainqueue_send_task_priority, NULL ); /* Create the software timer, but don't start it yet. */ xtimer = xtimercreate( "Timer", /* The text name assigned to the software timer. For debug only as it is not used by the kernel.*/ xtimerperiod, /* The period of the software timer in ticks. */ pdfalse, /* xautoreload is set to pdfalse, so this is a one shot timer. */ NULL, /* The timer's ID is not used. */ prvqueuesendtimercallback ); /* The function executed when the timer expires. */ } /* Start the tasks and timer running. */ vtaskstartscheduler(); } /* If all is well, the scheduler will now be running, and the following line will never be reached. If the following line does execute, then there was insufficient FreeRTOS heap memory available for the idle and/or timer tasksto be created. See the memory management section on the FreeRTOS web site for more details. */ for( ;; ); [1] Code example is the from FreeRTOS\Demo folder Slide 13 / TOC 6/20/2018 5:29:57 PM

$FreeRTOS Code example: function that is executed by the sender task static void prvqueuesendtask( void *pvparameters ) { TickType_t xnextwaketime; const TickType_t xblocktime =$

14 FreeRTOS Code example: function that is executed by the sender task static void prvqueuesendtask( void *pvparameters ) { TickType_t xnextwaketime; const TickType_t xblocktime = maintask_send_frequency_ms; const uint32_t ulvaluetosend = mainvalue_sent_from_task; } /* Prevent the compiler warning about the unused parameter. */ ( void ) pvparameters; /* Initialise xnextwaketime - this only needs to be done once. */ xnextwaketime = xtaskgettickcount(); for( ;; ) { /* Place this task in the blocked state until it is time to run again. The block time is specified in ticks, pdms_to_ticks() was used to convert a time specified in milliseconds into a time specified in ticks. While in the Blocked state this task will not consume any CPU time. */ vtaskdelayuntil( &xnextwaketime, xblocktime ); } /* Send to the queue - causing the queue receive task to unblock and write to the console. 0 is used as the block time so the send operation will not block - it shouldn't need to block as the queue should always have at least one space at this point in the code. */ xqueuesend( xqueue, &ulvaluetosend, 0U ); [1] Code example is the from FreeRTOS\Demo folder xblocktime = 200ms ulvaluetosend = 100 Get current time Set wake-up time for this task (periodic task): xnextwaketime + xblocktime Add value to queue Slide 14 / TOC 6/20/2018 5:29:57 PM

15 FreeRTOS Code example: function that is executed by the software timer static void prvqueuesendtimercallback( TimerHandle_t xtimerhandle ) { const uint32_t ulvaluetosend = mainvalue_sent_from_timer; ulvaluetosend = 200 } /* This is the software timer callback function. The software timer has a period of two seconds and is reset each time a key is pressed. This callback function will execute if the timer expires, which will only happen if a key is not pressed for two seconds. */ /* Avoid compiler warnings resulting from the unused parameter. */ ( void ) xtimerhandle; /* Send to the queue - causing the queue receive task to unblock and write out a message. This function is called from the timer/daemon task, so must not block. Hence the block time is set to 0. */ xqueuesend( xqueue, &ulvaluetosend, 0U ); Add value to queue [1] Code example is the from FreeRTOS\Demo folder Slide 15 / TOC 6/20/2018 5:29:57 PM

$FreeRTOS Code example: function that is executed by the receive task static void prvqueuereceivetask( void *pvparameters ) { uint32_t ulreceivedvalue; for( ;; ) { /* Wait until something arrives in$

16 FreeRTOS Code example: function that is executed by the receive task static void prvqueuereceivetask( void *pvparameters ) { uint32_t ulreceivedvalue; for( ;; ) { /* Wait until something arrives in the queue - this task will block indefinitely provided INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h. It will not use any CPU time while it is in the Blocked state. */ xqueuereceive( xqueue, &ulreceivedvalue, portmax_delay ); This code line will block/wait until there is something in queue. if( ulreceivedvalue == mainvalue_sent_from_task ) { printf( "Message received from task: %d\r\n", ulreceivedvalue ); } else if( ulreceivedvalue == mainvalue_sent_from_timer ) { printf( "Message received from software timer: %d\r\n", ulreceivedvalue); } else { printf( "Unexpected message\r\n" ); } } } /* Reset the timer if a key has been pressed. The timer will write mainvalue_sent_from_timer to the queue when it expires. */ if( _kbhit()!= 0 ) { /* Remove the key from the input buffer. */ ( void ) _getch(); /* Reset the software timer. */ xtimerreset( xtimer, portmax_delay ); } [1] Code example is the from FreeRTOS\Demo folder Reset software (one-shot) timer but only if a key has been pressed. Slide 16 / TOC 6/20/2018 5:29:57 PM

17 4. FreeRTOS and fighting priority inversion

18 FreeRTOS Does FreeRTOS support priority inversion ;-) Answer: a RTOS does not support (the evil problem of) priority inversion. It just happens. FreeRTOS supports priority inheritance to make the inversion time bounded [1] Discussion FreeRTOS and Priority Inversion on Slide 18 / TOC 6/20/2018 5:29:58 PM

19 5. Scheduling in FreeRTOS

FreeRTOS Where does the scheduling happen? Here: WindowsPort (FreeRTOS on top of the Windows scheduler) Scheduling code can be found in function prvprocesssimulatedinterrupts() in port.

20 FreeRTOS Where does the scheduling happen? Here: WindowsPort (FreeRTOS on top of the Windows scheduler) Scheduling code can be found in function prvprocesssimulatedinterrupts() in port.c: if( ulswitchrequired!= pdfalse ) { void *pvoldcurrenttcb; pvoldcurrenttcb = pxcurrenttcb; /* Select the next task to run. */ vtaskswitchcontext(); Within this function: decision which FreeRTOS thread to execute next /* If the task selected to enter the running state is not the task that is already in the running state. */ if( pvoldcurrenttcb!= pxcurrenttcb ) { /* Suspend the old thread. */ pxthreadstate = ( xthreadstate *) *( ( size_t * ) pvoldcurrenttcb ); SuspendThread( pxthreadstate->pvthread ); void vtaskswitchcontext( void ) {... /* Check for stack overflow, if configured. */ taskcheck_for_stack_overflow(); } /* Select a new task to run using either the generic C or port optimised asm code. */ taskselect_highest_priority_task(); tracetask_switched_in();... } } /* Ensure the thread is actually suspended by performing a synchronous operation that can only complete when the thread is actually suspended. The below code asks for dummy register data. */ xcontext.contextflags = CONTEXT_INTEGER; ( void ) GetThreadContext( pxthreadstate->pvthread, &xcontext ); /* Obtain the state of the task now selected to enter the Running state. */ pxthreadstate = ( xthreadstate * ) ( *( size_t *) pxcurrenttcb ); ResumeThread( pxthreadstate->pvthread ); Here: Windows API calls for suspending the old thread and resuming the new thread Slide 20 / TOC 6/20/2018 5:29:58 PM

21 6. Time in FreeRTOS

22 FreeRTOS How is time measured in FreeRTOS? FreeRTOS ticks: FreeRTOS kernel measures time using a tick count variable A hardware timer interrupt increments the tick count variable. This is done in the Tick ISR (Interrupt Service Routine) This allows the real time kernel to measure time up to the resolution of the used timer hardware How are ticks then generated in the WindowsPort if there is no specific hardware timer interrupt? Simulating the tick interrupt The tick interrupt generation is simulated by a high priority Windows thread that will periodically pre-empt the low priority threads that are running tasks. The tick rate achievable is limited by the Windows system clock, which in normal FreeRTOS terms is slow and has a very low precision. It is therefore not possible to obtain true real time behaviour. [1] [1] The RTOS tick [2] Quote is from Slide 22 / TOC 6/20/2018 5:29:58 PM

23 7. Crash course: Memory management

24 Memory Management Basics An operating system does not only administrate CPU time I need 5 MB of RAM. Task #1 I need 500 MB of RAM. Task #2 Operating System [1] 3D man with sun glasses (license: CC0, public domain) [2] 3D man butler (license: CC0, public domain) [3] RAM module (license: CC0, public domain) Slide 24 / TOC 6/20/2018 5:29:58 PM

Memory Management Basics Some time later I need more RAM: 15 MB, please!

Task #2 Operating System [1] 3D man with sun glasses https://pixabay.

25 Memory Management Basics Some time later I need more RAM: 15 MB, please! Task #1 I do not need the 500 MB of RAM any longer. Task #2 Operating System [1] 3D man with sun glasses (license: CC0, public domain) [2] 3D man butler (license: CC0, public domain) [3] RAM module (license: CC0, public domain) Slide 25 / TOC 6/20/2018 5:29:58 PM

26 Memory Management Basics Administration of memory. How? A key question in memory management: how to administrate a large memory? First approach: for each byte store a task ID RAM a single byte/word free byte Slide 26 / TOC 6/20/2018 5:29:58 PM

27 Memory Management Basics Administration of memory. How? We are very flexible! If there is a large memory request, we need to do a lot of administrative operations E.g., task wants 100 MB we need to collect and label of free bytes RAM a single byte/word free byte Slide 27 / TOC 6/20/2018 5:29:59 PM

28 Memory Management Basics Administration of memory. How? A lot of memory is needed as administration overhead: E.g., 2 16 = possible tasks we need 2 bytes to encode the task ID I.e., we need 2 bytes as label information for each byte To administrate 1 GB RAM we need 2 GB RAM! RAM a single byte/word free byte Slide 28 / TOC 6/20/2018 5:29:59 PM

29 Memory Management Basics Administration of memory. How? Ok, there is too much administrative overhead when using small memory blocks Second approach: use large blocks! E.g. divide 1 GB RAM into 1 MB blocks 1024 blocks to administrate RAM 1 MB a free MB Slide 29 / TOC 6/20/2018 5:29:59 PM

30 Memory Management Basics Administration of memory. How? Even large memory requests can be processed in short time Not much overhead, since we need 2 bytes to store the task ID for each block, but the block has now size 1 MB RAM 1 MB a free MB Slide 30 / TOC 6/20/2018 5:29:59 PM

31 Memory Management Basics Administration of memory. How? Problem: what if a task only needs 1 KB? We will reserve a 1 MB block for it we waste =1023 KB! RAM 1 MB a free MB Slide 31 / TOC 6/20/2018 5:29:59 PM

32 Memory Management Basics Memory block size usually used for administration Tradeoff between overhead ( use large block sizes) and waste ( use small block sizes) Slide 32 / TOC 6/20/2018 5:29:59 PM

33 Memory Management Basics Memory block size usually used for administration Tradeoff between overhead ( use large block sizes) and waste ( use small block sizes) /// file: get_memory_page_size_windows.cpp /// /// Here we use the SYSTEM_INFO data structure /// provided by Windows.h in order to determine /// the page size of the current system /// /// Note: the page size is determined by the /// CPU / MMU capabilities #include <stdio.h> #include <Windows.h> #include <conio.h> int main() { SYSTEM_INFO si; GetSystemInfo(&si); } printf("pagesize is %u bytes.\n", si.dwpagesize); _getch(); return 0; Slide 33 / TOC 6/20/2018 5:29:59 PM

Some instruction set architectures can support multiple page sizes: [1] [1]

34 Memory Management Basics How fix is the page size? Page size is not only determined by the OS, since also hardware (MMU) is Some instruction set architectures can support multiple page sizes: [1] [1] Slide 34 / TOC 6/20/2018 5:29:59 PM

Software Hardware Memory Management Basics Pseudo code for virtual memory management Memory management as pseudo code: [1] Pseudo-code is from

35 Software Hardware Memory Management Basics Pseudo code for virtual memory management Memory management as pseudo code: [1] Pseudo-code is from MIT lecture video MIT L17: Virtual Memory by Chris Ternan Slide 35 / TOC 6/20/2018 5:29:59 PM

36 8. Dynamic Memory Management and RTOS

37 Dynamic MM and RTOS Two problems of dynamic memory management for RTOS Slide 37 / TOC 6/20/2018 5:29:59 PM

38 9. What happens in the background if we allocate and free memory dynamically?

39 How does memory allocation work? Example in the following: malloc() This is the memory allocation method of the C runtime environment int* ptr=malloc(50000); your_application.exe ptr = 0x0AFFCD12 brk() or sbrk() for requesting more memory for the process C or C++ runtime Operating system Heap Note: there are different implementations of malloc() E.g., FreeBSD and NetBSD use jemalloc() from Jason Evans OpenBSD also has an own malloc() variant (using mmap) Hoard Memory Allocator Slide 39 / TOC 6/20/2018 5:29:59 PM

40 Experts discussing malloc() Sources: malloc() discussion on stackoverflow Slide 40 / TOC 6/20/2018 5:30:00 PM

41 How malloc()implementations often work: linked list of free blocks C runtime library has a data structure (linked list) of free memory blocks currently on the (so called) heap: Size of free block + ptr to next free one Size of data block #1 data block #1 Size of free block + ptr to next free one Size of data block #2 data block #2 Size of free block + ptr to next free one Size of data block #3 data block #3 Size of free block + ptr to next free one null Further reading: compare my slides with these: heap Slide 41 / TOC 6/20/2018 5:30:00 PM

42 How malloc()implementations often work: allocating a new block If new memory is needed during runtime of the application, malloc()first tries to find a suitable block on the heap: int* ptr=malloc(50000); Size of free block + ptr to next free one Size of free block + ptr to next free one Size of data block #1 Size of data block #1 data block #1 data block #1 Size of free block + ptr to next free one ptr Size of new block #4 data block #4 Size of free block + ptr to next free one Size of data block #2 Size of data block #2 data block #2 data block #2 Size of free block + ptr to next free one Size of free block + ptr to next free one Size of data block #3 Size of data block #3 data block #3 data block #3 Size of free block + ptr to next free one Size of free block + ptr to next free one null heap before malloc()call null heap after malloc()call Further reading: compare my slides with these: Slide 42 / TOC 6/20/2018 5:30:00 PM

43 How malloc() implementations often work: free block selection strategies Different strategies to find a suitable block: int* ptr=malloc(100000); 200 KB 100 KB 100 KB 200 KB 200 KB 100 KB 400 KB KB KB KB KB 175 KB 100 KB 75 KB 175 KB 350 KB 350 KB 350 KB 350 KB heap before malloc()call First fit Best fit Worst fit Legend: free memory block used memory block Slide 43 / TOC 6/20/2018 5:30:00 PM

44 How malloc() implementations often work: no suitable block found int* ptr=malloc(500000); 200 KB 400 KB KB 350 KB free memory block used memory block heap before malloc()call Slide 44 / TOC 6/20/2018 5:30:00 PM

heap before malloc()call heap after malloc()call How malloc() implementations often work: increasing heap size C runtime will ask operating system for

45 heap before malloc()call heap after malloc()call How malloc() implementations often work: increasing heap size C runtime will ask operating system for more memory pages, i.e., heap will grow 200 KB 200 KB 400 KB 200 brk() sbrk() 400 KB KB 175 KB 350 KB 2000 KB Slide 45 / TOC 6/20/2018 5:30:00 PM

46 How malloc()implementations often work: freeing a memory block Giving a memory block back to the C runtime library: free(ptr) Size of free block + ptr to next free one Size of free block + ptr to next free one Size of data block #1 data block #1 Size of free block + ptr to next free one Size of data block #1 data block #1 Size of free block + ptr to next free one ptr Size of data block #2 Size of free block + ptr to next free one free(ptr) data block #2 data block #2 Size of free block + ptr to next free one Size of free block + ptr to next free one Size of data block #3 data block #3 Size of free block + ptr to next free one Size of data block #3 data block #3 Size of free block + ptr to next free one heap null heap Slide 46 / TOC 6/20/2018 5:30:00 PM

47 When freeing a memory block a new question comes in Where to insert the new free block in the linked list of free blocks? or How to organize the linked list of free blocks? Organization approaches: Order free block information according to their memory addresses we need to find the correct insert place for the block just freed good if we want to merge adjacent free blocks to large ones Order free block information according to their sizes: we need to find the correct insert place for the block just freed increasing size good for best fit allocation approach decreasing size good for worst fit allocation approach Insert free blocks at end or start of linked list: no help for search/allocation strategies fast free() Sources: Approaches for organizing the linked list of free blocks Slide 47 / TOC 6/20/2018 5:30:00 PM

48 10. Available memory management strategies in FreeRTOS

49 FreeRTOS Memory Management Five different memory allocation schemes for different needs with increasing complexity. Can be found in: heap_1.c heap_5.c in FreeRTOSv9.0.0\FreeRTOS\Source\portable\MemMang Own implementation is possible: Memory allocation API is kept in portable layer of FreeRTOS allows specific implementation Instead of malloc() and free() the functions for allocating and free-ing memory are called: pvportmalloc() and vportfree() Sources: Memory Management in FreeRTOS Slide 49 / TOC 6/20/2018 5:30:00 PM

50 FreeRTOS Memory Management: heap_1.c Simplest method: allows only to allocate memory, but no free-ing! Sounds very restrictive, but is often no problem for many real-time applications Allocation: A large single array is divided into smaller blocks as new memory is needed Pros/Cons: simple algorithm for allocation fast and predictable time for allocation (O(1)) no free-ing of blocks When to use: If application never needs to delete a task, semaphore (mutex), queue, memory block If deterministic and fast memory allocation is needed Sources: Memory Management in FreeRTOS Slide 50 / TOC 6/20/2018 5:30:00 PM

$c (code snippet not complete) static size_t xnextfreebyte = ( size_t ) 0; void *pvportmalloc( size_t xwantedsize ) { void *pvreturn = NULL; static uint8_t *pucalignedheap = NULL;.$

51 FreeRTOS Memory Management: heap_1.c (code snippet not complete) static size_t xnextfreebyte = ( size_t ) 0; void *pvportmalloc( size_t xwantedsize ) { void *pvreturn = NULL; static uint8_t *pucalignedheap = NULL;... vtasksuspendall(); { if( pucalignedheap == NULL ) { } Suspends the scheduler without disabling interrupts. /* Ensure the heap starts on a correctly aligned boundary. */ pucalignedheap = ( uint8_t * ) ( ( ( portpointer_size_type ) &ucheap[ portbyte_alignment ] ) & ( ~( ( portpointer_size_type ) portbyte_alignment_mask ) ) ); /* Check there is enough room left for the allocation. */ if( ( ( xnextfreebyte + xwantedsize ) < configadjusted_heap_size ) && ( ( xnextfreebyte + xwantedsize ) > xnextfreebyte ))/* Check for overflow. */ { /* Return the next free byte then increment the index past this block. */ pvreturn = pucalignedheap + xnextfreebyte; xnextfreebyte += xwantedsize; } } tracemalloc( pvreturn, xwantedsize ); } ( void ) xtaskresumeall();... return pvreturn; Resumes the scheduler. Sources: Memory Management in FreeRTOS vtasksuspendall Slide 51 / TOC 6/20/2018 5:30:01 PM

52 FreeRTOS Memory Management: heap_2.c Allocation: uses a best fit algorithm Free-ing: blocks can be freed compared to heap_1.c No coalescence: it does not combine adjacent free blocks into a single large block xportgetfreeheapsize()api function can return the total amount of heap space, but does not provide information about the fragmentation status Can be used: when application needs to allocate and free memory blocks Pros/Cons: memory can be freed memory free-ing is simple algorithm fast memory allocation time is not good predictable, depends on fragmentation status Fragmentation may lead to situations where overall free heap size is sufficient for a pvportmalloc() call, but not available as a continuous block Code walkthrough: heap_2.c file Sources: Memory Management in FreeRTOS Slide 52 / TOC 6/20/2018 5:30:01 PM

53 FreeRTOS Memory Management: heap_3.c Wrapper around C malloc() and free() functions Allows to use standard C memory allocation / freeing methods with the same name as all other heap memory management approaches: pvportmalloc() and vportfree() Wrapper class also makes calls to malloc() and free() thread-safe Code walkthrough: heap_3.c file Sources: Memory Management in FreeRTOS Slide 53 / TOC 6/20/2018 5:30:01 PM

54 FreeRTOS Memory Management: heap_3.c void *pvportmalloc( size_t xwantedsize ) { void *pvreturn; vtasksuspendall(); { pvreturn = malloc( xwantedsize ); tracemalloc( pvreturn, xwantedsize ); } ( void ) xtaskresumeall(); } return pvreturn; /* */ void vportfree( void *pv ) { if( pv ) { vtasksuspendall(); { free( pv ); tracefree( pv, 0 ); } ( void ) xtaskresumeall(); } } Sources: Memory Management in FreeRTOS Slide 54 / TOC 6/20/2018 5:30:01 PM

55 FreeRTOS Memory Management: heap_4.c Allocation: first fit algorithm Free-ing: combines adjacent free blocks into a single large block: case 1 case 2 case 3 case 4 Block to be freed block used block free Pros/Cons: Memory fragmentation not that problematic as compared to heap_2.c even if memory being allocated and free is of random size Even harder to predict memory free times Code walkthrough: heap_4.c file Note, that blocks are now ordered in the linked list according to their memory addresses and not according to their (increasing) sizes as in heap_2.c Sources: Memory Management in FreeRTOS Slide 55 / TOC 6/20/2018 5:30:01 PM

56 FreeRTOS Memory Management: heap_5.c Allocation: same first fit algorithm as in heap_4.c Free-ing: block coalescence algorithm as in heap_4.c Difference to heap_4.c: heap_5.c allows the heap to span over multiple non-contiguous memory regions memory Note: a single allocated memory block cannot span over multiple regions! heap region #1 heap region #2 Sources: Memory Management in FreeRTOS Slide 56 / TOC 6/20/2018 5:30:01 PM

57 FreeRTOS Memory Management: heap_5.c To define the heap regions, the function vportdefineheapregions() is used: A single heap region is described by the following structure: typedef struct HeapRegion { uint8_t *pucstartaddress; size_t xsizeinbytes; } HeapRegion_t; A heap definition could look like this (regions have to be specified by increasing address sizes): /* Allocate two blocks of RAM for use by the heap. The first is a block of 0x10000 bytes starting from address 0x , and the second a block of 0xa0000 bytes starting from address 0x The block starting at 0x has the lower start address so appears in the array fist. */ const HeapRegion_t xheapregions[] = { { ( uint8_t * ) 0x UL, 0x10000 }, { ( uint8_t * ) 0x UL, 0xa0000 }, { NULL, 0 } /* Terminates the array. */ }; /* Pass the array into vportdefineheapregions(). */ vportdefineheapregions( xheapregions );; Sources: Memory Management in FreeRTOS Slide 57 / TOC 6/20/2018 5:30:01 PM

58 FreeRTOS Memory Management: heap_5.c In vportdefineheapregions() the defined heap regions are transformed into an initial list of free blocks, where each heap region is one large free block: memory memory heap region #1 free block #1 heap region #2 free block #2 Sources: Memory Management in FreeRTOS Slide 58 / TOC 6/20/2018 5:30:01 PM

Embedded Systems. 5. Operating Systems. Lothar Thiele. Computer Engineering and Networks Laboratory

Embedded Systems. 5. Operating Systems. Lothar Thiele. Computer Engineering and Networks Laboratory Embedded Systems 5. Operating Systems Lothar Thiele Computer Engineering and Networks Laboratory Embedded Operating Systems 5 2 Embedded Operating System (OS) Why an operating system (OS) at all? Same