ARRAYSYNC ALTERNATIVE 32 BIT
ARRAYSYNC ALTERNATIVE CODE

Should be exactly the kind of cleverness that hackers would relish Take advantage of unsigned integer wraparound. The years, and before being forced to really think about it, I'd always So here's the question: Why do people use the version that's inferiorĪnd more complicated? I've must have written a dozen ring buffers over

ARRAYSYNC ALTERNATIVE CODE

In it a code review so casually that it seems to have been a The earliest instance IĬould find with a bit of searching was from 2004, with Andrew Morton The extra memory as having to maintain the extra state.Īll of those seem like non-issues. In a way that could be interpreted as stealing the top bit of the

ARRAYSYNC ALTERNATIVE 32 BIT

(So 2^31-1 when using 32 bit unsigned integers). The maximum capacity can only be half the range of the indexĭata types.It's required for the code to be correct on unsigned It applies even if mask were defined using modular arithmetic or aĬonditional. Limitation does not come just from the definition of mask The capacity must always be a power of two.So you'll need to manually restrict their range anyway). Which will be bad, or they get promoted to doubles which will be worse. Happen in these languages is that the indices get promoted to bignums If it doesn't, this approach doesn't really buy anything. The implementation language supports wraparound on unsigned.This all works, assuming the following restrictions: That implementation looks basically like: Is done by masking the value after an index gets incremented. Offset, and then increment the write index.īoth indices will always be in the range 0.(capacity - 1). Index into the array by the write index, store the value in that Index, and then increment the read index. Value from the head of the queue, index into the array by the read One is to use an array as the backing storage plus two indices There are two common ways of implementing a queue with a ring buffer. After giving it a bit of thought, I realized I'd alwaysīeen writing ring buffers 'wrong', and there was a better way.

It was just surprisingly annoying to write, due to reasons we'll I'm sure you'll agree, is a perfectly reasonable data structure. So there I was, implementing a one element ring buffer.

Arraysync alternative