As suggested by @kvark, Something that maps a pulse to data.

Possible Api:

fn add(&mut self, pulse: Pulse, value: T);

/// As part of Iterator
fn next(&mut self) -> Option<(Pulse, T)>;

In order to let a pulse be waited on my multiple waiters we need a few features added.

• Cloning of pulse
• Reference counting of the pulse
• Chaining of Waiting objects

One possible way:

Reference Counting

I think the state AtomicUsize could me multi tasked. We can use it as a flag and a reference count. The highest nibble would be saved for the flags. When the trigger is dropped it sets the highest bit as triggered 0x8xxx_xxxx and for dropped 0x4xxx_xxxx. The reference count is the lowest 30 bits.

When a Pulse is dropped it just decrements the entire. It deletes the Pulse's memory if the lowest 30 bits were equal to 1 && the dropped flag 0x4xxx_xxxx is set. If the trigger sets the flags and finds the lowest bits were 0, it will drop the packet since there is no Pulse left.

Wait list

Each wait object just needs a next: Option<Next> to chain wait lits. Atom already has a LIFO function to help locklessly chain these items.

Since all Pulses are the same, this is a good target for a object pool.

Select was initially build around a Mutexed core just to make sure the logic worked correctly. There is a way to modify the internals of the Select to use a giant atomic bitset. Each bit maps to a Signal.

I'm not sure how much sense this constructor makes, the usize had to be a pointer to a value in the heap, which has been allocated by Box.

I'm convinced that there is a way to trigger a pulse -> signal with only a single CAS.

Right now there is three opeartions

• Atomic or to set a flag,
• Atomic swap to read the pending waitlist
• Atomic dec to mark the trigger as ready to free

The or and the dec cannot be merged because the waitlist needs to be read and is protected by the value of the dec.

This line for example shouldn't use Relaxed.