I have a need for a fixed-size (selectable at run-time when creating it, not compile-time) circular buffer which can hold objects of any type and it needs to be very high performance. I don’t think there will be resource contention issues since, although it’s in a multi-tasking embedded environment, it’s a co-operative one so the tasks themselves can manage that.
My initial thought was to store a simple struct in the buffer which would contain the type (simple enum/define) and a void pointer to the payload but I want this to be as fast as possible so I’m open to suggestions that involve bypassing the heap.
Actually I’m happy to bypass any of the standard library for raw speed – from what I’ve seen of the code, it’s not heavily optimized for the CPU : it looks like they just compiled C code for things like strcpy() and such, there’s no hand-coded assembly.
Any code or ideas would be greatly appreciated. The operations required are:
- create a buffer with specific size.
- put at the tail.
- get from the head.
- return the count.
- delete a buffer.
Can you enumerate the types needed at the time you code up the buffer, or do you need to be able to add types at run time via dynamic calls? If the former, then I would create the buffer as a heap-allocated array of n structs, where each struct consists of two elements: an enum tag identifying the data type, and a union of all the data types. What you lose in terms of extra storage for small elements, you make up in terms of not having to deal with allocation/deallocation and the resulting memory fragmentation. Then you just need to keep track of the start and end indices that define the head and tail elements of the buffer, and make sure to compute mod n when incrementing/decrementing the indices.