refslots 0.2.0

Reference-counted handles to slots in a slotmap
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use parking_lot::RwLock;
use std::{
    sync::{Arc, Barrier},
    thread,
};

const THREADS: usize = 8;
const ITERS: usize = 10_000;

slotmap::new_key_type! {
    struct Id;
}

type Handle = refslots::Handle<Id>;
type RegistryCell = Arc<RwLock<refslots::Registry<Id>>>;

/// Tests that while a strong handle is held, clone, upgrade, and drop from many threads never fails
/// an upgrade, never releases the slot, and never leaks the count.
#[test]
fn clone_upgrade_drop() {
    let registry = RegistryCell::default();
    let primary = Handle::insert(&registry, ());
    let key = primary.key();
    let weak = primary.downgrade();

    thread::scope(|s| {
        for _ in 0..THREADS {
            let weak = weak.clone();
            let held = primary.clone(); // dropped on different thread than created it
            s.spawn(move || {
                for _ in 0..ITERS {
                    // Primary handle is live, so the upgrade can never fail.
                    let strong = weak.upgrade().expect("slot is live");
                    let clone = strong.clone();
                    drop(strong);
                    drop(clone);
                }
                drop(held);
            });
        }
    });

    // Every thread's references are gone. Only the primary handle remains.
    assert_eq!(registry.read().strong_count(key), Some(1));
    assert_eq!(registry.write().take_released().count(), 0);

    drop(primary);
    assert!(registry.read().strong_count(key).is_none());

    let released = registry.write().take_released().collect::<Vec<_>>();
    assert_eq!(released, [key]);
    assert!(weak.upgrade().is_none());
}

const RACE_ROUNDS: usize = 100;

/// Tests the race between the last strong drop and concurrent upgrades. For any interleaving, the
/// slot must be released exactly once, an upgrade must either fully succeed or fail, and no thread
/// should observe a revived slot.
#[test]
fn last_drop_upgrade_race() {
    for _ in 0..RACE_ROUNDS {
        let registry = RegistryCell::default();
        let primary = Handle::insert(&registry, ());
        let key = primary.key();
        let weak = primary.downgrade();

        let barrier = Barrier::new(THREADS + 1);
        thread::scope(|s| {
            for _ in 0..THREADS {
                let weak = weak.clone();
                let barrier = &barrier;
                s.spawn(move || {
                    barrier.wait();
                    for _ in 0..ITERS {
                        let Some(strong) = weak.upgrade() else { continue };
                        assert_eq!(strong.key(), key);
                        drop(strong);
                    }
                });
            }
            barrier.wait();
            drop(primary); // primary handle races against the upgrading threads
        });

        // All handles are gone. The slot should be released exactly once.
        assert!(registry.read().strong_count(key).is_none());

        let released = registry.write().take_released().collect::<Vec<_>>();
        assert_eq!(released, [key]);
        assert!(weak.upgrade().is_none());
    }
}