带时间戳的环形缓冲区

Question

I have a need for a ring buffer (In C language) which can hold objects of any type at the run time (almost the data will be different signal's values like current (100ms and 10ms) and temperature.etc) ( I am not sure if it have to be a fixed size or not) and it needs to be very high performance. although it's in a multi-tasking embedded environment.

Actually i need this buffer as a back up, which mean the embedded software will work as normal and save the data into the ring buffer, so far for any reason and when an error occurred, then i could have like a reference for the measured values then i will be able to have a look on them and determine the problem. Also i need to make a time stamp on the ring buffer, which mean every data (Signal value) is stored on the ring buffer will stored with the measurement's time.

Any code or ideas would be greatly appreciated. some of the operations required are:

create a ring buffer with specific size. Link it with the whole software. put at the tail. get from the head. at error, read the data and when its happen (time stamp). return the count. overwrite when the buffer is being full.

#include<stdint.h>
#include<stdio.h>
#include<stdlib.h>

typedef struct ring_buffer
{
     void * buffer;      // data buffer
     void * buffer_end;  // end of data buffer
     void * data_start;  // pointer to head
     void * data_end;    // pointer to tail
     uint64_t capacity;  // maximum number of items in buffer
     uint64_t count;     // number of items in the buffer
     uint64_t size;      // size of each item in the buffer
 } ring_buffer;

 void rb_init (ring_buffer *rb, uint64_t size, uint64_t capacity )
 {
     rb->buffer = malloc(capacity * size);
         if(rb->buffer == NULL)
             // handle error
         rb->buffer_end = (char *)rb->buffer + capacity * size;
         rb->capacity = capacity;
         rb->count = 0;
         rb->size = size;
         rb->data_start = rb->buffer;
         rb->data_end = rb->buffer;
 }

 void cb_free(ring_buffer *rb)
 {
     free(rb->buffer);
     // clear out other fields too, just to be safe
 }

 void rb_push_back(ring_buffer *rb, const void *item)
 {
     if(rb->count == rb->capacity){
         // handle error
     }
     memcpy(rb->data_start, item, rb->size);
     rb->data_start = (char*)rb->data_start + rb->size;
     if(rb->data_start == rb->buffer_end)
         rb->data_start = rb->buffer;
     rb->count++;
 }

 void rb_pop_front(ring_buffer *rb, void *item)
 {
     if(rb->count == 0){
         // handle error
     }
     memcpy(item, rb->data_end, rb->size);
     rb->data_end = (char*)rb->data_end + rb->size;
     if(rb->data_end == rb->buffer_end)
         rb->data_end = rb->buffer;
     rb->count--;
 }

Answer 1

Creating a ring buffer/FIFO with hardcopies of generic type is highly questionable design for embedded systems. You shouldn't need that high level of abstraction for code so close to the hardware.

Either you make a ring buffer with a data type tag (like an enum) plus a void* to data allocated elsewhere, or you make a ring buffer where all data is of the same type. Everything else is most likely confused program design ("XY problem").

You need some means to lock access to the ring buffer internally, to make it thread-safe/interrupt-safe. This, as well as the time stamp, has to be handled internally by the ring buffer ADT.