ringbuffer | Ring buffer that allows for high-throughput data transfer

Previous answers may help as background:
c++, std::atomic, what is std::memory_order and how to use them?
https://bartoszmilewski.com/2008/12/01/c-atomics-and-memory-ordering/

Firstly the system you describe is known as a Single Producer - Single Consumer queue. You can always look at the boost version of this container to compare. I often will examine boost code, even when I work in situations where boost is not allowed. This is because examining and understanding a stable solution will give you insights into problems you may encounter (why did they do it that way? Oh, I see it - etc). Given your design, and having written many similar containers I will say that your design has to be careful about distinguishing empty from full. If you use a classic {begin,end} pair, you hit the problem that due to wrapping

{begin, begin+size} == {begin, begin} == empty

Okay, so back synchronisation issue.

Given that the order only effects reording, the use of release in Publish seems a textbook use of the flag. Nothing will read the value until the size of the container is incremented, so you don't care if the orders of writes of the value itself happen in a random order, you only care that the value must be fully written before the count is increased. So I would concur, you are correctly using the flag in the Publish function.
I did question whether the "release" was required in the Consume, but if you are moving out of the queue, and those moves are side-effecting, it may be required. I would say that if you are after raw speed, then it may be worth making a second version, that is specialised for trivial objects, that uses relaxed order for incrementing the head.

You might also consider inplace new/delete as you push/pop. Whilst most moves will leave an object in an empty state, the standard only requires that it is left in a valid state after a move. explicitly deleting the object after the move may save you from obscure bugs later.

You could argue that the two atomic loads in consume could be memory_order_consume. This relaxes the constraints to say "I don't care what order they are loaded, as long as they are both loaded by the time they are used". Although I doubt in practice it produces any gain. I am also nervous about this suggestion because when I look at the boost version it is remarkably close to what you have. https://www.boost.org/doc/libs/1_66_0/boost/lockfree/spsc_queue.hpp

Indeed, the problem was in the stb_vorbis.c file, whose #define's conflict with the standard library. I discovered this by isolating from stb and then going to this file.

I was inspired by the solution here. It was suitable to me to rearrange #include directives in such a way that stb_vorbis.c was at the end of the list. Now it is possible to build the entire project completely.

FileManager.cpp:

I think you figured it out, but just for you to compare:

You need synchronization between interrupt handlers and the "main-thread", so yes a sort of mutex is needed. The usual method without OS, is to just disable interrupts before "entering the critical section" and re-enable afterwards. That ensures the critical section is "atomic" (i.e. no interrupts fire in the meantime).

On ARM I would use a compare and swap instruction

What compiler are you using?

GCC and Clang has intrinsics for atomic compare-and-swap.

See e.g.

https://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html

https://llvm.org/docs/Atomics.html

C11 supports it via I believe: https://en.cppreference.com/w/c/atomic/atomic_compare_exchange

There is no happens before edge between a write to an array at some position and a read from the same position. So if you don't have any ordering guarantee in place, your code is suffering from a data race.

If you also allow for concurrent offers and concurrent polls, then you also have race conditions on your hands.

It has been quite some time I played with ringbuffers. But normally you make use of a tail and head sequence (e.g. a long). If you make the ringbuffer a power of 2, you can do a cheap mod on the conversion of the sequences to indices. And the head and tail sequence could be relatively expensive volatiles (I really would start with that) and later on you could play with relaxed memory order modes. The head and tail will give you the appropriate happens before edges so don't need to do anything special to the array. With this approach you can also get rid of the 'size'; you can calculate the size as the difference between tail and thehead; the problem with size is that it will cause contention between a thread read/writing to the ringbuffer. Also you need to properly pad the the head/tail fields to prevent false sharing.

Jersey 3.0 is an implementation of Jakarta RESTful Web Services 3.0, which is part of Jakarta EE 9.

This is the first version, which uses the new jakarta.* package namespace instead of the old namespace javax.*. Therefore Jersey 3.0 works only with other Jakarta EE 9 technologies and is not compatible with Jakarta EE 8 specifications.

If you wish to use Jersey 3.0, you need to upgrade to Tomcat 10.

RingBuffer::readAvailable() is returning a small negative number as a size_t. Since size_t is an unsigned type and because you're using %lu in the printf, it's being displayed as though it's a huge unsigned long. (Somehow your output has extra digits.)

It's possible RingBuffer has a bug. It seems to assume that that tail index will always be less then or equal to the head index. I'm not an expert in the memory ordering constraints used in lockless code, but it looks to me like it could be a synchronization problem with when it reads the head and tail to compute the amount available.

@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 *