Are dynamic memory allocation and the freeing of memory inefficient on your small device? The OSS’ Memory Handle API can provide you with more efficient allocation and freeing of memory. You can create a "memory handle" which is a linked list of large memory blocks, and allow the memory allocation function to allocate small segments of these memory blocks as needed, rather than inefficiently calling dynamic memory allocation functions (such as malloc() and free()) each time you need to allocate or release memory. This is especially useful when the message you are decoding contains a large number of output memory fragments. Rather than calling malloc() for each fragment, each decoder request for memory will be satisfied by a small segment of memory from the large blocks in the "memory handle", thus avoiding costly calls to malloc() for dynamic memory allocation.
When it is time to free the memory allocated for the complex structure that you decoded, you can either "release" those pieces of memory individually so that they can be reused by future requests for memory, or you can release or free all of blocks of memory for a particular "memory handle" in a single function call, thereby not needing to traverse the complex message structure to make sure each individual memory fragment is released. This means that when you have several decode operations, you can simply release all memory between decode operations rather than freeing it, thus being able to reuse this memory for your next decode.
Using OSS’ Memory Handle API, you can also create different "pools" of memory which can be used for different purposes. A simple function call can set which memory pool is currently active. This can be particularly useful in a multithreaded environment where you may have a different memory pool for messages which will only be handled by the current thread vs. a memory pool for messages which could be passed to other threads.
If you need further control over memory allocation and freeing, you can even replace the default system functions (malloc and free) with your own versions of these functions.
If your platform does not allow dynamic memory allocation, you can still use OSS’ Memory Handle API to use static memory as the "pool" from which fragments of memory are given to the encoder or decoder.