1

I'm developing a C-library to be used under uCOS-III. The CPU is an ARM Cortex M4 SAM4C. Within the library I want to use a third party product X, whose particular name is not relevant here. The source code for X is completely available and compiles without problems.

Inside X a lot of memory allocations are executed, using calloc() and free(). The problem is, that plain usage of malloc is not advisable for embedded systems, because of memory fragmentation. The documentation for uCOS-III explicitly advises against using malloc - instead OSMemCreate/OSMemGet/OSMemPut shall be used to allocate and free chunks of memory out of a statically allocated memory block.

Question-1:

What is the general advice to get around the "standard implementation" of malloc? I would prefer a kind of malloc, where I have access to a fixed memory pool (e.g. dedicated for a special task)

Question-2:

How should OSMemCreate() be used correctly? I have first to initialize a memory partition with a certain block size. The amount of requested memory is between 4 Bytes and about 800 bytes. I can get blocks on request, but with fixed size. If block-size=4 I cannot allocate 16 Bytes, since blocks are not contiguous in memory. If block-size=800 and I need only 4 bytes, most of the block is left unused and I will very soon run out of blocks.

So I don't know, how to solve my original problem by use of OSMemCreate...

Can anybody give me an advice how I could proceed?

Many thanks, Michael

MichaelW
  • 1,328
  • 1
  • 15
  • 32
  • Fragmentation is perhaps the least of issues with malloc in a real-time system. The default malloc is neither deterministic nor intrinsically thread safe . Allocations take variable time and may fail, and if a thread is preempted part way through an allocation or free and the preempting thread then performs an alloc/free operation, the heap management will become corrupted in a manner that may not cause a noticeable behaviour until some subsequent alloc/free. Your C library may have hooks to provide thread-safety via a mutex, but that may further impact real-time deterministic behaviour – Clifford Sep 07 '16 at 18:38

1 Answers1

2

1) Don't link with the standard library version of malloc/free. Instead create your own implementation of malloc/free that serves as a wrapper to OSMemGet/OSMemPut.

2) You can create more than one memory partition with OSMemCreate. Create small, medium, and large partitions that hold block sizes which are tuned for your application to reduce waste.

If you want malloc to get an appropriately sized block from your various memory partitions then you'll have to invent some magic so that free returns the block to the appropriate memory partition. (Perhaps malloc allocates an extra word, stores the pointer to the memory partition in the first word, and then returns the address after the word where the pointer is stored. Then free knows to get the memory partition pointer from the preceding word.)

An alternative to using malloc/free is to rewrite that code to use statically allocated variables or call OSMemGet/OSMemPut directly.

kkrambo
  • 6,643
  • 1
  • 17
  • 30