Concurrency Coordination Reports

OnceLock Coordination Report

A write-once report records single initialization. This program offers a selected number of writes to a OnceLock and reports accepted versus rejected sets along with the stored value.

Program

Play the program to choose how many writes are offered and watch the cell accept the first and reject the rest.

writes
once_lock_coordination_report.rs
Replay: real traced execution (multi-file project)
use std::sync::OnceLock;

fn main() {
    let writes = 2;
    let cell = OnceLock::new();
    let mut accepted = 0;
    let mut rejected = 0;
    for value in 1..=writes {
        match cell.set(value) {
            Ok(()) => accepted += 1,
            Err(_) => rejected += 1,
        }
    }
    let stored = cell.get().copied();
    let status = if accepted == 0 {
        "unset"
    } else if rejected > 0 {
        "locked"
    } else {
        "set"
    };
    println!("accepted={accepted} rejected={rejected} stored={stored:?} {status}");
}

use std::sync::OnceLock;

fn main() {
    let writes = 0;
    let cell = OnceLock::new();
    let mut accepted = 0;
    let mut rejected = 0;
    for value in 1..=writes {
        match cell.set(value) {
            Ok(()) => accepted += 1,
            Err(_) => rejected += 1,
        }
    }
    let stored = cell.get().copied();
    let status = if accepted == 0 {
        "unset"
    } else if rejected > 0 {
        "locked"
    } else {
        "set"
    };
    println!("accepted={accepted} rejected={rejected} stored={stored:?} {status}");
}

use std::sync::OnceLock;

fn main() {
    let writes = 1;
    let cell = OnceLock::new();
    let mut accepted = 0;
    let mut rejected = 0;
    for value in 1..=writes {
        match cell.set(value) {
            Ok(()) => accepted += 1,
            Err(_) => rejected += 1,
        }
    }
    let stored = cell.get().copied();
    let status = if accepted == 0 {
        "unset"
    } else if rejected > 0 {
        "locked"
    } else {
        "set"
    };
    println!("accepted={accepted} rejected={rejected} stored={stored:?} {status}");
}

  1. writes ← 2, cell ← OnceLock(<uninit>), accepted ← 0, rejected ← 0

    3fn main() {4    let write→ 2s = 2; //@writes=2, 0, 15    let cel→ OnceLock(<uninit>)l = OnceLock::new();6    let mut accepte→ 0d = 0;7    let mut rejecte→ 0d = 0;8    for value in 1..=writes {

  2. for value in 1..=writes

    pass 1 of 2
    7let mut rejected = 0;8for valu1e in 1..=write2s {9    match cell.set(value) {

  3. for value in 1..=writes

    pass 2 of 2
    7let mut rejected = 0;8for valu2e in 1..=write2s {9    match cell.set(value) {

  4. stored ← Some(1), status ← "locked"

    13    }14    let store→ Some(1)d = cell.get().copied();15    let statu→ "locked"s = if accepte1d == 0 {16        "unset"17    } else if rejecte1d > 0 {18        "locked"19    } else {20        "set"21    };22    println!("accepted={accepted} rejected={rejected} stored={stored:?} {status}");23}
    outputaccepted=1 rejected=1 stored=Some(1) locked

  1. writes ← 0, cell ← OnceLock(<uninit>), accepted ← 0, rejected ← 0

    3fn main() {4    let write→ 0s = 0;5    let cel→ OnceLock(<uninit>)l = OnceLock::new();6    let mut accepte→ 0d = 0;7    let mut rejecte→ 0d = 0;8    for value in 1..=writes {9        match cell.set(value) {10            Ok(()) => accepted += 1,11            Err(_) => rejected += 1,12        }13    }14    let store→ Noned = cell.get().copied();15    let statu→ "unset"s = if accepte0d == 0 {16        "unset"17    } else if rejecte0d > 0 {18        "locked"19    } else {20        "set"21    };22    println!("accepted={accepted} rejected={rejected} stored={stored:?} {status}");23}
    outputaccepted=0 rejected=0 stored=None unset

  1. writes ← 1, cell ← OnceLock(<uninit>), accepted ← 0, rejected ← 0

    3fn main() {4    let write→ 1s = 1;5    let cel→ OnceLock(<uninit>)l = OnceLock::new();6    let mut accepte→ 0d = 0;7    let mut rejecte→ 0d = 0;8    for value in 1..=writes {

  2. for value in 1..=writes

    7let mut rejected = 0;8for valu1e in 1..=write1s {9    match cell.set(value) {

  3. stored ← Some(1), status ← "set"

    13    }14    let store→ Some(1)d = cell.get().copied();15    let statu→ "set"s = if accepte1d == 0 {16        "unset"17    } else if rejecte0d > 0 {18        "locked"19    } else {20        "set"21    };22    println!("accepted={accepted} rejected={rejected} stored={stored:?} {status}");23}
    outputaccepted=1 rejected=0 stored=Some(1) set
write-once cell `OnceLock::set` accepts the first value and rejects every later write, so initialization happens exactly once.
stored value `OnceLock::get` returns the stored value after a successful set and `None` before any set.
set report The accepted and rejected counts report whether the cell stayed unset, was set once, or locked out a later write.