runmat-execution 0.6.2

Portable identities, handles, resource models, value payloads, and protocol contracts for RunMat execution
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use runmat_execution::identity::{Digest, NodeLeaseId, ValueId, WorkerId};
use runmat_execution::value::{
    DenseValue, ElementType, InlineValue, RegisteredData, RegisteredField, ResidentFence,
    SparseValue, ValueLimits, ValuePayload, ValueRef, ValueRefKind,
};

#[test]
fn nested_payloads_obey_depth_and_node_limits() {
    let payload = ValuePayload::Inline(Box::new(InlineValue::Cell {
        shape: vec![1],
        values: vec![ValuePayload::Inline(Box::new(InlineValue::Cell {
            shape: vec![1],
            values: vec![ValuePayload::Inline(Box::new(InlineValue::Logical(true)))],
        }))],
    }));
    assert!(payload
        .validate(ValueLimits {
            max_depth: 1,
            ..ValueLimits::default()
        })
        .is_err());
    assert!(payload.validate(ValueLimits::default()).is_ok());
}

#[test]
fn struct_fields_must_be_sorted_and_unique() {
    use runmat_execution::value::StructField;
    let scalar = || ValuePayload::Inline(Box::new(InlineValue::Logical(true)));
    let payload = ValuePayload::Inline(Box::new(InlineValue::Struct(vec![
        StructField {
            name: "z".into(),
            value: scalar(),
        },
        StructField {
            name: "a".into(),
            value: scalar(),
        },
    ])));
    assert!(payload.validate(ValueLimits::default()).is_err());
}

#[test]
fn dense_and_sparse_storage_must_match_declared_shapes() {
    let dense = ValuePayload::Inline(Box::new(InlineValue::Dense(DenseValue {
        element_type: ElementType::F64,
        shape: vec![2, 2],
        little_endian_data: vec![0; 24],
    })));
    assert!(dense.validate(ValueLimits::default()).is_err());

    let sparse = ValuePayload::Inline(Box::new(InlineValue::Sparse(SparseValue {
        element_type: ElementType::F64,
        rows: 2,
        columns: 2,
        column_offsets: vec![0, 2, 1],
        row_indices: vec![0],
        little_endian_data: vec![0; 8],
    })));
    assert!(sparse.validate(ValueLimits::default()).is_err());
}

#[test]
fn registered_fields_are_validated_without_projecting_live_values() {
    let scalar = || ValuePayload::Inline(Box::new(InlineValue::Logical(true)));
    let payload = ValuePayload::Inline(Box::new(InlineValue::Symbolic(RegisteredData {
        type_identity: "symbolic/v1".into(),
        schema_version: 1,
        fields: vec![
            RegisteredField {
                name: "z".into(),
                value: scalar(),
            },
            RegisteredField {
                name: "a".into(),
                value: scalar(),
            },
        ],
    })));
    assert!(payload.validate(ValueLimits::default()).is_err());
}

#[test]
fn resident_values_require_and_bind_a_worker_fence() {
    let mut reference = ValueRef {
        schema_version: runmat_execution::schema::VALUE_PAYLOAD_SCHEMA_V1,
        id: ValueId::derive(&[b"value"]),
        logical_digest: Digest::sha256(b"value"),
        encoded_length: 1,
        media_type: "application/runmat-value".into(),
        value_schema: "runmat-value/v1".into(),
        encryption_context: Digest::sha256(b"context"),
        kind: ValueRefKind::ResidentObject,
        authorization_scope: "scope".into(),
        resident_fence: None,
    };
    assert!(ValuePayload::Object(Box::new(reference.clone()))
        .validate(ValueLimits::default())
        .is_err());

    reference.resident_fence = Some(ResidentFence {
        worker_id: WorkerId::derive(&[b"worker"]),
        node_lease_id: NodeLeaseId::derive(&[b"lease"]),
        process_generation: 2,
        device_identity: Some("gpu-0".into()),
    });
    assert!(ValuePayload::Object(Box::new(reference.clone()))
        .validate(ValueLimits::default())
        .is_ok());

    reference.kind = ValueRefKind::ResultObject;
    assert!(ValuePayload::Object(Box::new(reference))
        .validate(ValueLimits::default())
        .is_err());
}

#[test]
fn logical_identity_is_independent_of_inline_or_object_placement() {
    let inline = ValuePayload::Inline(Box::new(InlineValue::String("payload".into())));
    let logical_digest = inline.logical_digest().unwrap();
    let reference = ValuePayload::Object(Box::new(ValueRef {
        schema_version: runmat_execution::schema::VALUE_PAYLOAD_SCHEMA_V1,
        id: ValueId::derive(&[b"value"]),
        logical_digest,
        encoded_length: 1024,
        media_type: "application/runmat-value".into(),
        value_schema: "runmat-value/v1".into(),
        encryption_context: Digest::sha256(b"context"),
        kind: ValueRefKind::ResultObject,
        authorization_scope: "scope".into(),
        resident_fence: None,
    }));
    assert_eq!(reference.logical_digest().unwrap(), logical_digest);

    let nested_inline = ValuePayload::Inline(Box::new(InlineValue::OutputList(vec![inline])));
    let nested_reference = ValuePayload::Inline(Box::new(InlineValue::OutputList(vec![reference])));
    assert_eq!(
        nested_inline.logical_digest().unwrap(),
        nested_reference.logical_digest().unwrap()
    );
}