How can I improve the performance of my ring buffer code?

I am using a ringbuffer to hold samples for a streaming audio application. I copied the ringbuffer implementation from Ken Greenebaum's Audio Anecdotes 2 book.

After running Intel's Vtune analyzer on my code, it tells me that most of the time is being spent in the functions getSamplesAvailable() and getSpaceAvailable().

Ca开发者_开发知识库n anyone advise as to how I might optimise these functions?

RingBuffer::getSamplesAvailable(void)
{
   int count = (mTail - mHead + mSize) % mSize;
   return(count);
}

unsigned int RingBuffer::getSpaceAvailable(void)
{
   int free = (mHead - mTail + mSize - 1)%mSize;
   int underMark = mHighWaterMark - getSamplesAvailable();
   int spaceAvailable = min(underMark, free);
   return(spaceAvailable);
}

int RingBuffer::push(int value)
{
   int status = 1;
   if(getSpaceAvailable()) {
      // next two operations do NOT have to be atomic!
      // do NOT have to worry about collision with _tail
      mBuffer[mTail] = value;   // store value
      mTail = ++mTail % mSize;  // increment tail
  } else {
     status = 0;
  }
  return(status);
}

int RingBuffer::pop(int *value)
{
   int status = 1;
   if(getSamplesAvailable()) {
       *value = mBuffer[mHead];
       mHead = ++mHead % mSize;  // increment head
   } else {
      status = 0;
   }
   return(status);
}

If you can make mSize a power of two, you can replace

(mTail - mHead + mSize) % mSize

by

(mTail - mHead) & (mSize-1)

and

(mHead - mTail + mSize - 1) % mSize

by

(mHead - mTail - 1) & (mSize - 1)

I think the problem is not their complexity, they are just basic integer arithmetic, but how many times they are called.

Is there any possibility of doing "batch" (inserting or retrieving various values at once) updates on the buffer? That way you could save some calculations.

Using a power of two as Henrik proposed is the first thing to do. There is also the possibility to change the way you code the mTail and mHead indexes. Instead of keeping them in the [0, mSize[ range, you can let them run freely as uint32_t.

When accessing an element you will need to do a modulo mSize which will slow down each access.

mBuffer[mTail % mSize] = value;

But it will simpify for instance the count of samples (even if your indexes wrap over the uint32_t max value):

int count = mTail - mHead;

It will also allow you to fully use the ring buffer, instead of loosing one element to differentiate the cases where the buffer is full or empty.

If speed is the most important thing for you and you can live with the fact that it is a) non portable (only Windows, although linux has the same basic functionality as well so that should work there as well) and b) only works in release builds (well has more to do with how VC++ allocates memory in debug mode - probably there's some compile flag for this?) you can use the following:

DWORD size = 64 * 1024;  // HAS to be a multiple of 64k due to how win allocates memory
HANDLE mapped_memory = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, size, NULL);
int *p1 = (int*)MapViewOfFile(mapped_memory, FILE_MAP_WRITE, 0, 0, size);
int *p2 = (int*)MapViewOfFile(mapped_memory, FILE_MAP_WRITE, 0, 0, size);
// p1 and p2 should be adjacent in memory, if not try again.. no idea if there's some
// better method under windows

Basically you now have two adjacent memory blocks in virtual memory that point to the same physical memory. Ie if you write through pdw1 you'll see the changes in pdw2 and vice-versa.

The advantage is that you can now more efficiently read and write to the buffer and also larger amounts than only one word at a time. You just have to decrement the pointers correctly - shouldn't be too hard to implement.

Edit: Now see that - there's even a POSIX implementation on wiki.