Compiler Explorer

Source code

use std::sync::atomic::{AtomicU32, Ordering::*};

pub struct TidSeqLock {
    seq: AtomicU32,
    low: AtomicU32,
    high: AtomicU32,
}

impl TidSeqLock {
    pub fn read(&self) -> u64 {
        // synchronizes with the release increment in `write()` to ensure data
        // is only read after it's fully written.
        let mut seq = self.seq.load(Acquire);
        loop {
            if seq % 2 == 0 {
                let low = self.low.load(Relaxed);
                let high = self.high.load(Relaxed);
                let tid = (u64::from(high) << 32) | u64::from(low);
                // use a release store to ensure that the reads above don't see
                // the result of subsequent writes. the acquire increment in `write()`
                // synchronizes with this.
                // note that while this is technically susceptible to the ABA problem,
                // similar cases like Condvar just ignore this, as you would need exactly
                // 1 << 31 writes to trigger it.
                match self.seq.compare_exchange_weak(seq, seq, Release, Acquire) {
                    Ok(_) => return tid,
                    Err(new) => seq = new,
                }
            } else {
                seq = self.seq.load(Acquire);
            }
        }
    }

/// # Safety
    /// While simply calling this function can never lead to unsafety on its own,
    /// `read()` may return teared data if `write()` is called from multiple threads concurrently.
    /// To ensure that `read()` only returns correct values, `write()` must only be called by one
    /// thread at a time.
    pub unsafe fn write(&self, tid: u64) {
        // synchronizes with a successful cas in `read()`.
        self.seq.fetch_add(1, Acquire);
        self.low.store(tid as u32, Relaxed);
        self.high.store((tid >> 32) as u32, Relaxed);
        self.seq.fetch_add(1, Release);
    }
}