@Adriksh First time hearing about this. Thank you. Bookmarked already

@Adriksh I once implemented a ring buffer for something, no longer recall what. Worked a treat 🙂

@Adriksh super interesting read, and nice note on the atomics memory order.

@Adriksh Vecdeque et al exist in rust, it’s not c specific

@Adriksh and what's funny is that this is exactly what a ring buffer involving copies looks like. it's not zero copy

@Adriksh Thanks 4 sharing. U explain complicated concepts well. My days as a code writer have ended many years ago and while I believe the "new generation" is far more talented l, capable, & has tools we could only dream of, they lack basic understanding that would make them 10x better.

@Adriksh "no memcpy" -> writes a bytewise memory copy manually and stores the whole data in the ring. The way to do this right is to pair it with an object pool and pass the pointers through the ring. That is zero copy. Of course your object pool is likely to use the same structure.

@Adriksh Small but critical nit: your & (BUFFER_SIZE - 1) wraparound only works if BUFFER_SIZE is a power of two. Otherwise it’s not a modulo and the ring buffer will break.

@Adriksh Wow i was looking for this

@Adriksh Nice refresher! Looking forward to a similar write-up on MPMC implementation using CAS

@Adriksh If the slot content fits into a single world you can use it both to check wrapping/emptiness in offer/poll - enabling interesting optimization like looking ahead by N for emptiness. That distribute the contention vs the producer/consume sequences

@Adriksh Looks like an old LMAX Disruptor pattern.

@Adriksh An important point is that the acquire loads let previous instructions be reordered after it. This means that tail can be loaded after head, but not after the following instructions because of data dependency. This guarantees correctness.

@Adriksh Cool bro!

@Adriksh This leaves a lot of performance on the table. Count cache misses per message! See intel.com/content/www/us…

@Adriksh Nice, i add mutex and call it a day Seems like this will be an interesting read Keep up these articles

@Adriksh Been using ring buffers since my early days writing async communications code in the 80's.

@Adriksh Slop

@Adriksh In push I think you’re still missing std::atomic_thread_fence(std::memory_order_release); after writing data to ring buffer, but before updating atomic. You need to flush that data to be visible to other thread, otherwise only head and tail are guaranteed to be visible.

@Adriksh @ChristoPy_

@Adriksh Super cool

@Adriksh Interesting

@Adriksh @grok explain alignas(CACHE_LINE)

@Adriksh more bookmarks than likes :)

@Adriksh Why don't we use memcpy instead of running for loop ?

@Adriksh Thread safe with two parallel pushes? And why?

@Adriksh @sseraphini é oq?

@Adriksh NVMe drive host interface works this way.