sim-lib-machine 0.1.0

Neutral policy contracts for bounded decoded-instruction machines.
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
94
95
96
97
98
99
100
101
102
103
104

// conformance: neutral machine frames preserve bounded call and resume behavior.

use sim_kernel::{CodecId, Origin, SourceId, Span};
use sim_lib_control::{AdmissionLimit, WorkLimit};
use sim_lib_machine::{
    CallTransfer, Frame, FrameStack, FrameStackError, InstructionPolicy, LocatedCode,
    LocatedInstruction, SourceLocation, TransferError, ValueWidthPolicy,
};

struct Instructions;

impl InstructionPolicy for Instructions {
    type Instruction = u8;
    type InstructionId = u8;

    fn instruction_id(instruction: &Self::Instruction) -> Self::InstructionId {
        *instruction
    }
}

struct Values;

impl ValueWidthPolicy for Values {
    type Value = u64;

    fn width(_: &Self::Value) -> usize {
        1
    }
}

fn entry_cursor() -> sim_lib_machine::CodeCursor {
    let code = LocatedCode::<Instructions>::freeze(
        vec![LocatedInstruction::new(
            0,
            0,
            SourceLocation::Bytes(Origin {
                codec: CodecId(1),
                source: SourceId("frame-test".into()),
                span: Span { start: 0, end: 1 },
                trivia: vec![],
            }),
            false,
            None,
        )],
        vec![],
        vec![],
    )
    .expect("single located instruction is valid");
    code.entry()
}

#[test]
fn million_deep_chain_exhausts_declared_budget_without_host_recursion() {
    type TestFrame = Frame<Values, (), (), ()>;
    const FRAME_BUDGET: usize = 32;
    const REQUESTED_DEPTH: usize = 1_000_000;

    let cursor = entry_cursor();
    let mut frames = FrameStack::<TestFrame>::new(WorkLimit(FRAME_BUDGET));
    let mut outcome = Ok(());
    for _ in 0..REQUESTED_DEPTH {
        outcome = frames.push(Frame::new(
            AdmissionLimit(2),
            WorkLimit(2),
            cursor,
            None,
            (),
            (),
        ));
        if outcome.is_err() {
            break;
        }
    }

    assert_eq!(
        outcome,
        Err(FrameStackError::DepthExhausted {
            depth: FRAME_BUDGET,
            limit: FRAME_BUDGET,
        })
    );
    assert_eq!(frames.depth(), FRAME_BUDGET);
}

#[test]
fn transfers_are_only_code_references_values_and_widths() {
    let packet = CallTransfer::new(vec![10_u64, 20], vec![1, 2], "code:sum")
        .expect("aligned nonzero widths");
    assert_eq!(packet.target, "code:sum");
    assert_eq!(packet.values, [10, 20]);
    assert_eq!(packet.widths, [1, 2]);
    assert_eq!(
        CallTransfer::new(vec![10_u64], vec![], "code:bad"),
        Err(TransferError::WidthCountMismatch)
    );

    let source = include_str!("../src/frame.rs").to_ascii_lowercase();
    for forbidden in ["method", "signature", "class"] {
        assert!(
            !source.contains(forbidden),
            "transfer/frame module imported forbidden guest concept: {forbidden}"
        );
    }
}