我需要一个固定大小（可在运行时在创建时选择，而不是在编译时选择）的循环缓冲区，该缓冲区可以容纳任何类型的对象，并且需要非常高性能。我认为不会出现资源争用问题，因为尽管它是在多任务嵌入式环境中，但它是一种协作的环境，因此任务本身可以管理它。

我最初的想法是在缓冲区中存储一个简单的结构，该结构将包含类型（简单的enum / define）和一个指向有效负载的空指针，但是我希望这样做尽可能快，因此我对涉及绕过的建议持开放态度堆。

实际上，我很高兴绕过任何标准库以提高原始速度-从我对代码的了解来看，它没有针对CPU进行过大幅优化：看起来他们只是为诸如此类的东西编译了C代码，strcpy()没有手工编码的程序集。

任何代码或想法将不胜感激。所需的操作是：

• 创建具有特定大小的缓冲区。
• 放在尾巴。
• 从头上得到。
• 返回计数。
• 删除缓冲区。

您可以在对缓冲区进行编码时枚举所需的类型，还是需要在运行时通过动态调用添加类型？如果是前者，那么我将缓冲区创建为n个结构的堆分配数组，其中每个结构均包含两个元素：一个用于标识数据类型的枚举标记，以及一个所有数据类型的并集。就小元素的额外存储而言，您失去的是，不必处理分配/重新分配以及由此产生的内存碎片。然后，您只需要跟踪定义缓冲区的头和尾元素的开始索引和结束索引，并确保在增加/减少索引时计算mod n。

最简单的解决方案是跟踪项目大小和项目数，然后创建一个适当字节数的缓冲区：

typedef struct circular_buffer
{
    void *buffer;     // data buffer
    void *buffer_end; // end of data buffer
    size_t capacity;  // maximum number of items in the buffer
    size_t count;     // number of items in the buffer
    size_t sz;        // size of each item in the buffer
    void *head;       // pointer to head
    void *tail;       // pointer to tail
} circular_buffer;

void cb_init(circular_buffer *cb, size_t capacity, size_t sz)
{
    cb->buffer = malloc(capacity * sz);
    if(cb->buffer == NULL)
        // handle error
    cb->buffer_end = (char *)cb->buffer + capacity * sz;
    cb->capacity = capacity;
    cb->count = 0;
    cb->sz = sz;
    cb->head = cb->buffer;
    cb->tail = cb->buffer;
}

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

void cb_push_back(circular_buffer *cb, const void *item)
{
    if(cb->count == cb->capacity){
        // handle error
    }
    memcpy(cb->head, item, cb->sz);
    cb->head = (char*)cb->head + cb->sz;
    if(cb->head == cb->buffer_end)
        cb->head = cb->buffer;
    cb->count++;
}

void cb_pop_front(circular_buffer *cb, void *item)
{
    if(cb->count == 0){
        // handle error
    }
    memcpy(item, cb->tail, cb->sz);
    cb->tail = (char*)cb->tail + cb->sz;
    if(cb->tail == cb->buffer_end)
        cb->tail = cb->buffer;
    cb->count--;
}

// Note power of two buffer size
#define kNumPointsInMyBuffer 1024 

typedef struct _ringBuffer {
    UInt32 currentIndex;
    UInt32 sizeOfBuffer;
    double data[kNumPointsInMyBuffer];
} ringBuffer;

// Initialize the ring buffer
ringBuffer *myRingBuffer = (ringBuffer *)calloc(1, sizeof(ringBuffer));
myRingBuffer->sizeOfBuffer = kNumPointsInMyBuffer;
myRingBuffer->currentIndex = 0;

// A little function to write into the buffer
// N.B. First argument of writeIntoBuffer() just happens to have the
// same as the one calloc'ed above. It will only point to the same
// space in memory if the calloc'ed pointer is passed to
// writeIntoBuffer() as an arg when the function is called. Consider
// using another name for clarity
void writeIntoBuffer(ringBuffer *myRingBuffer, double *myData, int numsamples) {
    // -1 for our binary modulo in a moment
    int buffLen = myRingBuffer->sizeOfBuffer - 1;
    int lastWrittenSample = myRingBuffer->currentIndex;

    int idx;
    for (int i=0; i < numsamples; ++i) {
        // modulo will automagically wrap around our index
        idx = (i + lastWrittenSample) & buffLen; 
        myRingBuffer->data[idx] = myData[i];
    }

    // Update the current index of our ring buffer.
    myRingBuffer->currentIndex += numsamples;
    myRingBuffer->currentIndex &= myRingBuffer->sizeOfBuffer - 1;
}

只要环形缓冲区的长度是2的幂，那么令人难以置信的快速二进制“＆”运算将为您缠绕索引。对于我的应用程序，我正在从麦克风获取的音频环形缓冲区中向用户显示一段音频。

我始终确保屏幕上可以显示的最大音频量远小于环形缓冲区的大小。否则，您可能正在从同一块读取和写入。这可能会给您带来奇怪的显示效果。

首先，标题。如果使用位整数保存头和尾“指针”，并对其进行大小调整，以使它们完全同步，则不需要模运算来包装缓冲区。IE：填入12位unsigned int的4096本身就是0，无论如何都不会被破坏。消除模运算，即使对于2的幂，速度也几乎翻了一番。

在我的第三代i7 Dell XPS 8500上，使用Visual Studio 2010的C ++编译器（默认内联），进行1000万次填充和排空任何类型的数据元素的迭代需要52秒，而其中的1 / 8192nd则用于处理数据。

我会在main（）中RX重写测试循环，以使它们不再控制流程-应该并且应该由指示缓冲区已满或为空的返回值控制，并伴随中断；陈述。IE：填充物和排放物应该能够相互撞击，而不会损坏或不稳定。在某些时候，我希望对该代码进行多线程处理，因此该行为至关重要。

QUEUE_DESC（队列描述符）和初始化函数强制此代码中的所有缓冲区均为2的幂。以上方案否则将无法正常工作。在主题上，请注意QUEUE_DESC并不是硬编码的，它使用清单常量（#define BITS_ELE_KNT）进行构造。（我假设此处的2的幂足够灵活）

为了使缓冲区大小运行时可以选择，我尝试了不同的方法（此处未显示），并决定将USHRT用于能够管理FIFO缓冲区的Head，Tail和EleKnt。为避免取模算术，我使用Head，Tail为&&创建了一个掩码，但是该掩码原来是（EleKnt -1），因此只需使用它即可。在安静的计算机上，使用USHRTS代替bit ints可将性能提高约15％。英特尔CPU内核始终比其总线快，因此在繁忙的共享计算机上，打包数据结构可让您在其他竞争线程之前加载并执行。权衡。

注意，缓冲区的实际存储空间是使用calloc（）在堆上分配的，并且指针位于结构的基础上，因此结构和指针的地址完全相同。IE浏览器；无需将偏移量添加到结构地址即可绑定寄存器。

同样，为缓冲区提供服务的所有变量在物理上都与缓冲区相邻，并绑定到同一结构中，因此编译器可以编写漂亮的汇编语言。您必须终止内联优化才能看到任何程序集，因为否则它会被粉碎。

为了支持任何数据类型的多态性，我使用了memcpy（）而不是赋值。如果您只需要灵活性来支持每个编译中的一个随机变量类型，那么此代码将完美运行。

对于多态，您只需要知道类型及其存储要求即可。描述符的DATA_DESC数组提供了一种跟踪放入QUEUE_DESC.pB​​uffer中的每个数据的方式，以便可以正确地检索它。我只分配了足够的pBuffer内存来容纳最大数据类型的所有元素，但是在DATA_DESC.dBytes中跟踪给定数据实际使用了多少存储空间。另一种方法是重新发明堆管理器。

这意味着QUEUE_DESC的UCHAR * pBuffer将具有一个并行的伴随数组来跟踪数据类型和大小，而数据在pBuffer中的存储位置将保持不变。如果您可以找到一种通过这种前向引用击败编译器提交的方法，则新成员将类似于DATA_DESC * pDataDesc或DATA_DESC DataDesc [2 ^ BITS_ELE_KNT]。在这些情况下，Calloc（）总是更加灵活。

您仍然可以在Q_Put（），Q_Get中使用memcpy（），但是实际复制的字节数将由DATA_DESC.dBytes而不是QUEUE_DESC.EleBytes决定。对于任何给定的放置或获取，元素都可能具有不同的类型/大小。

我相信这段代码可以满足速度和缓冲区大小的要求，并且可以满足6种不同数据类型的要求。我以printf（）语句的形式保留了许多测试装置，因此您可以（或不可以）对代码正常工作感到满意。随机数生成器演示该代码可用于任何随机的头/尾组合。

enter code here
// Queue_Small.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <stdio.h>
#include <time.h>
#include <limits.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <math.h>

#define UCHAR unsigned char
#define ULONG unsigned long
#define USHRT unsigned short
#define dbl   double
/* Queue structure */
#define QUEUE_FULL_FLAG 1
#define QUEUE_EMPTY_FLAG -1
#define QUEUE_OK 0
//  
#define BITS_ELE_KNT    12  //12 bits will create 4.096 elements numbered 0-4095
//
//typedef struct    {
//  USHRT dBytes:8;     //amount of QUEUE_DESC.EleBytes storage used by datatype
//  USHRT dType :3; //supports 8 possible data types (0-7)
//  USHRT dFoo  :5; //unused bits of the unsigned short host's storage
// }    DATA_DESC;
//  This descriptor gives a home to all the housekeeping variables
typedef struct  {
    UCHAR   *pBuffer;   //  pointer to storage, 16 to 4096 elements
    ULONG Tail  :BITS_ELE_KNT;  //  # elements, with range of 0-4095
    ULONG Head  :BITS_ELE_KNT;  //  # elements, with range of 0-4095
    ULONG EleBytes  :8;     //  sizeof(elements) with range of 0-256 bytes
    // some unused bits will be left over if BITS_ELE_KNT < 12
    USHRT EleKnt    :BITS_ELE_KNT +1;// 1 extra bit for # elements (1-4096)
    //USHRT Flags   :(8*sizeof(USHRT) - BITS_ELE_KNT +1);   //  flags you can use
    USHRT   IsFull  :1;     // queue is full
    USHRT   IsEmpty :1;     // queue is empty
    USHRT   Unused  :1;     // 16th bit of USHRT
}   QUEUE_DESC;

//  ---------------------------------------------------------------------------
//  Function prototypes
QUEUE_DESC *Q_Init(QUEUE_DESC *Q, int BitsForEleKnt, int DataTypeSz);
int Q_Put(QUEUE_DESC *Q, UCHAR *pNew);
int Q_Get(UCHAR *pOld, QUEUE_DESC *Q);
//  ---------------------------------------------------------------------------
QUEUE_DESC *Q_Init(QUEUE_DESC *Q, int BitsForEleKnt, int DataTypeSz)    {
    memset((void *)Q, 0, sizeof(QUEUE_DESC));//init flags and bit integers to zero
    //select buffer size from powers of 2 to receive modulo 
    //                arithmetic benefit of bit uints overflowing
    Q->EleKnt   =   (USHRT)pow(2.0, BitsForEleKnt);
    Q->EleBytes =   DataTypeSz; // how much storage for each element?
    //  Randomly generated head, tail a test fixture only. 
    //      Demonstrates that the queue can be entered at a random point 
    //      and still perform properly. Normally zero
    srand(unsigned(time(NULL)));    // seed random number generator with current time
    Q->Head = Q->Tail = rand(); // supposed to be set to zero here, or by memset
    Q->Head = Q->Tail = 0;
    //  allocate queue's storage
    if(NULL == (Q->pBuffer = (UCHAR *)calloc(Q->EleKnt, Q->EleBytes)))  {
        return NULL;
    }   else    {
        return Q;
    }
}
//  ---------------------------------------------------------------------------
int Q_Put(QUEUE_DESC *Q, UCHAR *pNew)   
{
    memcpy(Q->pBuffer + (Q->Tail * Q->EleBytes), pNew, Q->EleBytes);
    if(Q->Tail == (Q->Head + Q->EleKnt)) {
        //  Q->IsFull = 1;
        Q->Tail += 1;   
        return QUEUE_FULL_FLAG; //  queue is full
    }
    Q->Tail += 1;   //  the unsigned bit int MUST wrap around, just like modulo
    return QUEUE_OK; // No errors
}
//  ---------------------------------------------------------------------------
int Q_Get(UCHAR *pOld, QUEUE_DESC *Q)   
{
    memcpy(pOld, Q->pBuffer + (Q->Head * Q->EleBytes), Q->EleBytes);
    Q->Head += 1;   //  the bit int MUST wrap around, just like modulo

    if(Q->Head == Q->Tail)      {
        //  Q->IsEmpty = 1;
        return QUEUE_EMPTY_FLAG; // queue Empty - nothing to get
    }
    return QUEUE_OK; // No errors
}
//
//  ---------------------------------------------------------------------------
int _tmain(int argc, _TCHAR* argv[])    {
//  constrain buffer size to some power of 2 to force faux modulo arithmetic
    int LoopKnt = 1000000;  //  for benchmarking purposes only
    int k, i=0, Qview=0;
    time_t start;
    QUEUE_DESC Queue, *Q;
    if(NULL == (Q = Q_Init(&Queue, BITS_ELE_KNT, sizeof(int)))) {
        printf("\nProgram failed to initialize. Aborting.\n\n");
        return 0;
    }

    start = clock();
    for(k=0; k<LoopKnt; k++)    {
        //printf("\n\n Fill'er up please...\n");
        //Q->Head = Q->Tail = rand();
        for(i=1; i<= Q->EleKnt; i++)    {
            Qview = i*i;
            if(QUEUE_FULL_FLAG == Q_Put(Q, (UCHAR *)&Qview))    {
                //printf("\nQueue is full at %i \n", i);
                //printf("\nQueue value of %i should be %i squared", Qview, i);
                break;
            }
            //printf("\nQueue value of %i should be %i squared", Qview, i);
        }
        //  Get data from queue until completely drained (empty)
        //
        //printf("\n\n Step into the lab, and see what's on the slab... \n");
        Qview = 0;
        for(i=1; i; i++)    {
            if(QUEUE_EMPTY_FLAG == Q_Get((UCHAR *)&Qview, Q))   {
                //printf("\nQueue value of %i should be %i squared", Qview, i);
                //printf("\nQueue is empty at %i", i);
                break;
            }
            //printf("\nQueue value of %i should be %i squared", Qview, i);
        }
        //printf("\nQueue head value is %i, tail is %i\n", Q->Head, Q->Tail);
    }
    printf("\nQueue time was %5.3f to fill & drain %i element queue  %i times \n", 
                     (dbl)(clock()-start)/(dbl)CLOCKS_PER_SEC,Q->EleKnt, LoopKnt);
    printf("\nQueue head value is %i, tail is %i\n", Q->Head, Q->Tail);
    getchar();
    return 0;
}

这是C语言中的一个简单解决方案。假设每个功能都关闭了中断。没有多态性和东西，只是常识。

#define BUFSIZE 128
char buf[BUFSIZE];
char *pIn, *pOut, *pEnd;
char full;

// init
void buf_init()
{
    pIn = pOut = buf;       // init to any slot in buffer
    pEnd = &buf[BUFSIZE];   // past last valid slot in buffer
    full = 0;               // buffer is empty
}

// add char 'c' to buffer
int buf_put(char c)
{
    if (pIn == pOut  &&  full)
        return 0;           // buffer overrun

    *pIn++ = c;             // insert c into buffer
    if (pIn >= pEnd)        // end of circular buffer?
        pIn = buf;          // wrap around

    if (pIn == pOut)        // did we run into the output ptr?
        full = 1;           // can't add any more data into buffer
    return 1;               // all OK
}

// get a char from circular buffer
int buf_get(char *pc)
{
    if (pIn == pOut  &&  !full)
        return 0;           // buffer empty  FAIL

    *pc = *pOut++;              // pick up next char to be returned
    if (pOut >= pEnd)       // end of circular buffer?
        pOut = buf;         // wrap around

    full = 0;               // there is at least 1 slot
    return 1;               // *pc has the data to be returned
}

一个简单的实现可以包括：

• 缓冲区，实现为大小为n的数组，无论您需要哪种类型
• 读指针或索引（以对您的处理器更有效的方式为准）
• 写指针或索引
• 指示缓冲区中有多少数据的计数器（可从读取和写入指针派生，但分别跟踪速度更快）

每次写入数据时，都会前进写入指针并增加计数器。读取数据时，增加读取指针并减少计数器。如果任一指​​针到达n，请将其设置为零。

如果counter = n，则无法写入。如果counter = 0，则无法读取。

C样式，整数的简单环形缓冲区。首先使用init而不是put和get。如果缓冲区不包含任何数据，则返回“ 0”零。

//=====================================
// ring buffer address based
//=====================================
#define cRingBufCount   512
int     sRingBuf[cRingBufCount];    // Ring Buffer
int     sRingBufPut;                // Input index address
int     sRingBufGet;                // Output index address
Bool    sRingOverWrite;

void    GetRingBufCount(void)
{
int     r;
`       r= sRingBufPut - sRingBufGet;
        if ( r < cRingBufCount ) r+= cRingBufCount;
        return r; 
}

void    InitRingBuffer(void)
{
        sRingBufPut= 0;
        sRingBufGet= 0;
}       

void    PutRingBuffer(int d)
{
        sRingBuffer[sRingBufPut]= d;
        if (sRingBufPut==sRingBufGet)// both address are like ziro
        {
            sRingBufPut= IncRingBufferPointer(sRingBufPut);
            sRingBufGet= IncRingBufferPointer(sRingBufGet);
        }
        else //Put over write a data
        {
            sRingBufPut= IncRingBufferPointer(sRingBufPut);
            if (sRingBufPut==sRingBufGet)
            {
                sRingOverWrite= Ture;
                sRingBufGet= IncRingBufferPointer(sRingBufGet);
            }
        }
}

int     GetRingBuffer(void)
{
int     r;
        if (sRingBufGet==sRingBufPut) return 0;
        r= sRingBuf[sRingBufGet];
        sRingBufGet= IncRingBufferPointer(sRingBufGet);
        sRingOverWrite=False;
        return r;
}

int     IncRingBufferPointer(int a)
{
        a+= 1;
        if (a>= cRingBufCount) a= 0;
        return a;
}

扩展adam-rosenfield的解决方案，我认为以下内容将适用于多线程单生产者-单消费者场景。

int cb_push_back(circular_buffer *cb, const void *item)
{
  void *new_head = (char *)cb->head + cb->sz;
  if (new_head == cb>buffer_end) {
      new_head = cb->buffer;
  }
  if (new_head == cb->tail) {
    return 1;
  }
  memcpy(cb->head, item, cb->sz);
  cb->head = new_head;
  return 0;
}

int cb_pop_front(circular_buffer *cb, void *item)
{
  void *new_tail = cb->tail + cb->sz;
  if (cb->head == cb->tail) {
    return 1;
  }
  memcpy(item, cb->tail, cb->sz);
  if (new_tail == cb->buffer_end) {
    new_tail = cb->buffer;
  }
  cb->tail = new_tail;
  return 0;
}

@Adam罗森菲尔德的解决方案，虽然是正确的，可以用一个更轻量级的实现circular_buffer结构不invlovecount和capacity。

该结构只能容纳以下4个指针：

• buffer：指向内存中缓冲区的开始。
• buffer_end：指向内存中缓冲区的末尾。
• head：指向已存储数据的末尾。
• tail：指向存储数据的开始。

我们可以保留该sz属性以允许对存储单位进行参数化。

无论是count和capacity值应该汲取，能够使用上述指针。

容量

capacity是直截了当的，因为可以通过将buffer_end指针与buffer指针之间的距离除以存储单位来得出sz（下面的代码段是伪代码）：

capacity = (buffer_end - buffer) / sz

计数

值得一提的是，事情变得更加复杂。例如，有没有办法来确定缓冲区是否为空或满，在场景head和tail指向同一个位置。

为了解决这个问题，缓冲区应该为其他元素分配内存。例如，如果循环缓冲区的期望容量为10 * sz，则需要分配11 * sz。

容量公式将变为（下面的代码段是伪代码）：

capacity_bytes = buffer_end - buffer - sz
capacity = capacity_bytes / sz

这种额外的元素语义使我们能够构造评估缓冲区是空还是满的条件。

空状态条件

为了使缓冲区为空，head指针指向与指针相同的位置tail：

head == tail

如果以上计算结果为true，则缓冲区为空。

完整状态条件

为了使缓冲区已满，head指针应在tail指针后面1个元素。因此，为了从一个head位置跳到另一个位置而需要覆盖的空间tail应等于1 * sz。

如果tail大于head：

tail - head == sz

如果以上计算结果为true，则缓冲区已满。

如果head大于tail：

1. buffer_end - head返回从head缓冲区跳转到缓冲区末尾的空间。
2. tail - buffer 返回从缓冲区开始到尾部所需的空间。
3. 将上述2相加应等于从跳转head到tail
4. 在步骤3中得出的空间，不大于 1 * sz

(buffer_end - head) + (tail - buffer) == sz
=> buffer_end - buffer - head + tail == sz
=> buffer_end - buffer - sz == head - tail
=> head - tail == buffer_end - buffer - sz
=> head - tail == capacity_bytes

如果以上计算结果为true，则缓冲区已满。

在实践中

修改@Adam Rosenfield使其使用上述circular_buffer结构：

#include <string.h>

#define CB_SUCCESS 0        /* CB operation was successful */
#define CB_MEMORY_ERROR 1   /* Failed to allocate memory */
#define CB_OVERFLOW_ERROR 2 /* CB is full. Cannot push more items. */
#define CB_EMPTY_ERROR 3    /* CB is empty. Cannot pop more items. */

typedef struct circular_buffer {
  void *buffer;
  void *buffer_end;
  size_t sz;
  void *head;
  void *tail;
} circular_buffer;

int cb_init(circular_buffer *cb, size_t capacity, size_t sz) {
  const int incremented_capacity = capacity + 1; // Add extra element to evaluate count
  cb->buffer = malloc(incremented_capacity * sz);
  if (cb->buffer == NULL)
    return CB_MEMORY_ERROR;
  cb->buffer_end = (char *)cb->buffer + incremented_capacity * sz;
  cb->sz = sz;
  cb->head = cb->buffer;
  cb->tail = cb->buffer;
  return CB_SUCCESS;
}

int cb_free(circular_buffer *cb) {
  free(cb->buffer);
  return CB_SUCCESS;
}

const int _cb_length(circular_buffer *cb) {
  return (char *)cb->buffer_end - (char *)cb->buffer;
}

int cb_push_back(circular_buffer *cb, const void *item) {
  const int buffer_length = _cb_length(cb);
  const int capacity_length = buffer_length - cb->sz;

  if ((char *)cb->tail - (char *)cb->head == cb->sz ||
      (char *)cb->head - (char *)cb->tail == capacity_length)
    return CB_OVERFLOW_ERROR;

  memcpy(cb->head, item, cb->sz);

  cb->head = (char*)cb->head + cb->sz;
  if(cb->head == cb->buffer_end)
    cb->head = cb->buffer;

  return CB_SUCCESS;
}

int cb_pop_front(circular_buffer *cb, void *item) {
  if (cb->head == cb->tail)
    return CB_EMPTY_ERROR;

  memcpy(item, cb->tail, cb->sz);

  cb->tail = (char*)cb->tail + cb->sz;
  if(cb->tail == cb->buffer_end)
    cb->tail = cb->buffer;

  return CB_SUCCESS;
}