vyre-self-substrate 0.6.2

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
69
70

use super::*;
use vyre_foundation::ir::Program;

pub(super) struct DominatorDispatcher {
    pub(super) outputs: Vec<Vec<u8>>,
}

impl OptimizerDispatcher for DominatorDispatcher {
    fn dispatch(
        &self,
        _program: &Program,
        inputs: &[Vec<u8>],
        grid_override: Option<[u32; 3]>,
    ) -> Result<Vec<Vec<u8>>, DispatchError> {
        assert_eq!(grid_override, Some([1, 1, 1]));
        if inputs.len() != 6 {
            return Err(DispatchError::BadInputs(format!(
                "Fix: dominator frontier test dispatcher expected 6 inputs, got {}.",
                inputs.len()
            )));
        }
        Ok(self.outputs.clone())
    }
}

pub(super) struct DominatorInputShapeDispatcher;

impl OptimizerDispatcher for DominatorInputShapeDispatcher {
    fn dispatch(
        &self,
        _program: &Program,
        inputs: &[Vec<u8>],
        grid_override: Option<[u32; 3]>,
    ) -> Result<Vec<Vec<u8>>, DispatchError> {
        assert_eq!(grid_override, Some([1, 1, 1]));
        assert_eq!(inputs.len(), 6);
        assert_eq!(
            inputs[1].len(),
            4,
            "Fix: empty dominance targets must be padded to one u32 from the primitive plan"
        );
        assert_eq!(
            inputs[3].len(),
            4,
            "Fix: empty predecessor targets must be padded to one u32 from the primitive plan"
        );
        Ok(vec![u32_slice_to_le_bytes(&[0])])
    }
}

pub(super) struct RecordingDominatorDispatcher {
    pub(super) calls: Mutex<Vec<Vec<Vec<u8>>>>,
    pub(super) output: Vec<u8>,
}

impl OptimizerDispatcher for RecordingDominatorDispatcher {
    fn dispatch(
        &self,
        _program: &Program,
        inputs: &[Vec<u8>],
        grid_override: Option<[u32; 3]>,
    ) -> Result<Vec<Vec<u8>>, DispatchError> {
        assert_eq!(grid_override, Some([1, 1, 1]));
        self.calls
            .lock()
            .expect("Fix: recording dispatcher calls lock should not be poisoned")
            .push(inputs.to_vec());
        Ok(vec![self.output.clone()])
    }
}