RingBuffer | A simple ring buffer for ISR-task communication

@IInspectable was right, there's something wrong with my code : the audio processing is done by a library which then calls callbacks with some results.

In my callback, I try to raise a winrt::event, but it sometimes takes more than 50ms. When it happens, it blocks the audio thread, and creates discontinuity...

rings.get():

This is getting raw pointer from rings which gives you RingBuffer *

rings_->ring1_.get():

I suppose you mean rings->ring1_.get(), which first dereferences rings and then get raw pointer from member ring1_. It is the same with rings.get()->ring1_.get(). The final result is a RingBufferLock *

USB CDC and all serial protocols derived from RS-232 implement stream-based communication, i.e. a potentially endless stream of bytes.

They do not implement message-based communication. Therefore, they have no concept of messages, and no concept of message start and message end.

The lower layers of USB are message based. So you might observe patterns that look like a message-based communication. You might also think that USB CDC is message based because the STM32cube framework exposes a USB API that will deliver more data whenever a low-level USB message has arrived.

But this behavior can only be observed if small chunks of data are sent with pauses in-between and if the USB bus is mostly idle. It collapses if speed is increased or the USB bus becomes busier.

Then your PC will start to merge chunks of data. This can be easily tested by sending 100 times 10 bytes as fast as possible. The first 10 bytes are likely sent in its own packet. But the remaining data will be merged and sent as packets of 64 bytes (except for the last few bytes).

So if you want to have a message-oriented protocol on top of stream-oriented protocol, the two typical approaches are:

• Use a delimiter between messages. As an example: If you have a human-readable text protocol, a linefeed is often used as the delimiter. Once you encounter a linefeed character, you know you have a complete message (i.e. line).

• Use a length indicator at the end of the message. This is useful for binary protocols. The first two bytes could contain the message length in bytes, encoded as a 16-bit number. So will be obvious when the message is complete.

Also note that a received packet can contain several message, or the end of a message and the start of the next message.

The function ringBufferInit does not make a sense. In the function testRingBufferPushPopSingle you already created an object of the type RingBuffer.

Your problem lies in the absence of a move assignment operator. Looking at your class, you have defaulted this operation.

Unfortunately, = default means that you get the default behavior, not that this method is created. This is really confusing.

To make this easier to spot I've recently enabled the following clang warning as error on the code base I'm working on: https://clang.llvm.org/docs/DiagnosticsReference.html#wdefaulted-function-deleted (Maybe GCC has something similar)

Long story short, if you have a base class or member that doesn't allow this operation, your class can't default this.

In this case, you have a reference as a member, as one can't reassign a reference, one can't provide the assignment operator.

Possible workarounds are: store as a raw pointer, or store as std:: reference_wrapper.

PS: please make your deleted methods public and use = delete, it will give much better error messages

It's possible to do it this way:

You can't "call" anything inside a struct. A struct contains definitions of its members, not code.

You can initialize a member in a constructor:

args is for constructor arguments. if you change an arg, the object will re-instanciate, as in: is the same as new Foo(123). animating something that constructs 60fps is a no go, and it's also not possible with react-spring. in praxis you should find means to mutate things as fast as possible, if you can get away with it animate scale, or make a ring shader whose uniforms you animate.

Spelunking a bit finally led me to the PR in which huonw has the exact same reaction you did:

I find this mapping weird: it seems like tail should be head (as in, that element is the head of the ringbuf) and vice versa.

What's the motivation for having them this way around?

to which the PR author replies that it follows the linux kernel terminology. Which never explains why it's using the terms it does.

The PR also specifically notes that

lo, nelts [nb: the old names for these fields] are replaced by a more traditional head and tail

So the answer seems to be "because it follows traditional nomenclature". Might be that one original paper used these terms and it stuck, or could be happenstance. The internets certainly don't seem interested in this question as while the terms show up aplenty explanations don't.

The linux circular buffers document was only added in 2010 so it would be documenting the existing state of affairs, and struct circ_buf called it that when the Git repo was created back in 2005, so if you want more you'd have to dive into the historical archive and hope there are references there.