vyre-self-substrate 0.6.3

Vyre self-substrate: vyre using its own primitives on its own scheduler problems. The recursion-thesis layer between vyre-primitives and vyre-driver.
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

use super::super::*;
use super::support::RecordingResidentDispatcher;
use crate::graph::csr_frontier_queue_scratch::ResidentCsrQueueMaterializer;

#[test]
fn generated_resident_csr_queue_free_releases_each_handle_once_in_first_seen_order() {
    for seed in 0..4096_u64 {
        let dispatcher = RecordingResidentDispatcher::default();
        let base = 30_000 + seed * 16;
        let graph = ResidentCsrQueueGraph {
            node_count: 4,
            edge_count: 3,
            max_row_degree: 1,
            high_degree_source_count: 0,
            words: 1,
            edge_offsets_handle: base,
            edge_targets_handle: base + 1,
            edge_kind_mask_handle: base,
        };
        graph.free(&dispatcher).expect("Fix: graph free dedup");
        assert_eq!(dispatcher.freed.borrow().as_slice(), &[base, base + 1]);

        dispatcher.freed.borrow_mut().clear();
        let mut scratch = ResidentCsrQueueScratch::default();
        scratch.handles = Some(ResidentCsrQueueScratchHandles {
            frontier: base + 2,
            active_queue: base + 2,
            queue_len: base + 3,
            frontier_out: base + 4,
            word_partials: None,
            block_totals: None,
            high_queue: None,
            high_len: None,
            queue_capacity: 4,
            high_queue_capacity: 0,
            frontier_bytes: 4,
            materializer: ResidentCsrQueueMaterializer::AtomicWordScan,
        });
        scratch.free(&dispatcher).expect("Fix: scratch free dedup");
        assert_eq!(
            dispatcher.freed.borrow().as_slice(),
            &[base + 2, base + 3, base + 4]
        );

        dispatcher.freed.borrow_mut().clear();
        scratch.handles = Some(ResidentCsrQueueScratchHandles {
            frontier: base + 5,
            active_queue: base + 6,
            queue_len: base + 6,
            frontier_out: base + 7,
            word_partials: Some(base + 8),
            block_totals: Some(base + 8),
            high_queue: Some(base + 9),
            high_len: Some(base + 9),
            queue_capacity: 4,
            high_queue_capacity: 1,
            frontier_bytes: 4,
            materializer: ResidentCsrQueueMaterializer::DeterministicWordPrefix,
        });
        scratch
            .free(&dispatcher)
            .expect("Fix: word-prefix scratch free dedup");
        assert_eq!(
            dispatcher.freed.borrow().as_slice(),
            &[base + 5, base + 6, base + 7, base + 8, base + 9]
        );
    }
}