tower120/rc_event_queue

VecDeque-like fast, unbounded, mpmc/spmc concurent FIFO message queue. Lockless reads, write-lock writes.

rc_event_queue's Issues

total_capacity can be O(1)

also update truncate_front

Try optimise `EventQueue::extend`

EventReader can be Clonable

But is that needed?

EventQueue::new() type inference not working

RecycledChunksList

EventReader::new()

Construct EventReader with new() instead of EventQueue::subscribe

Try not push if no readers

Try check readers_count in push/extend, instead of

        if S::AUTO_CLEANUP {
            if self.readers.load(Ordering::Relaxed) == 0{
                self.cleanup_impl(&mut list);
            }
        }

in clear/truncate/resize

Do that after spmc implementation.
Benchmark.

no_std compatibility

subscribe/unsubscribe can be O(1)

Have readers_count in each chunk. On Subscribe/unsubscribe +/-1 read_completely_times only on last chunk.

spmc implementation

Implement spmc through dummy lock + EventQueue mut interfaces.

try copy iterator

isolate_readers feature

somewhat like truncate_front but for readers.

encode in ChunkState special code for reader to switch to isolator_chunk (size=0, always return None).
Also change Event to null, and decrease EventQueue reader count (have special unsubscribe?).

Have separate isolated_list_first in EventQueue?

Try built-in `have_next_chunk` bit into `Chunk::len_and_epoch`

Instead of testing

            let next_chunk = chunk.next().load(Ordering::Acquire);
            if next_chunk == null_mut(){
                return None;
            }
            if chunk.len_and_epoch(Ordering::Acquire).len() as usize != self.chunk_len{
                return None;
            }

in EventReader. Store have_next_chunk bit in atomic Chunk::len_and_epoch "bitarray". if at current len there is next chunk - it is safe to switch.

spmc EventReader::new_sync(&EventReader)