Circular buffer optimizations - c++

Question

I've got a circular buffer that has size power of 2. My goal is to optimize its work. Here's brief code:
class CircularBuffer
{
public:
CircularBuffer(unsigned int bufferSize); // align this size to power of 2
void read(char * dst, unsigned int bytes);
void write(char * src, unsigned int bytes);
private:
unsigned int m_readOffset;
unsigned int m_writeOffset;
std::vector<char> m_buffer;
};
CircularBuffer::write(char * src, unsigned int bytes)
{
int dif = bytes - (m_buffer.size() - m_writeOffset);
unsigned int mask = ~(dif >> 31); // 0 or 0xFFFFFFFF
dif &= mask; // now i know how much bytes i need to put at the beginning of the buffer
memcpy(&m_buffer[m_writeOffset], src, bytes - dif);
memcpy(&m_buffer[0], src + bytes - dif, dif);
m_writeOffset = (m_wirteffset + bytes) & (m_buffer.size() -1);
}
m_writeOffset indicates how many bytes already put in buffer.
As you can see I get rid of conditions like if (remain size in buff < srcSize) etc, and calculate writeOffset using bitmask.
But my lead programmer tells me there's a way to calculate how many bytes to put at the end of the buffer and how many bytes to put at the start using bitwise operations, because size of buffer is power of 2. Any suggestions?

Answer 1

You are already using unsigned variables to keep track of the front and back of your queue (this is good); simply increment m_writeOffset on each write (enqueue) operation and increment m_readOffset on each read (dequeue) operation. Calculating the remaining amount of buffer elements is as simple as:
// returns the distance between m_readOffset and m_writeOffset
// (the count of the actual buffer elements):
uint32_t CircularBuffer::Size()
{
if (m_readOffset < m_writeOffset)
{
return (m_writeOffset - m_readOffset);
}
else
{
return (m_readOffset - m_writeOffset);
}
}
Check out the source code to my STL template implementation of a base-2 circular queue:
CircularQueue.h
CircularQueue.cpp