tenferro-runtime 0.8.0

Concrete tensor helpers, traced tensors, graph execution, and extension runtime support for tenferro.
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

//! Public `Debug` contract coverage for engine registration descriptors.

use std::fmt::Debug;
use std::sync::Arc;

use tenferro_runtime::{
    CoreCapabilityBundle, EngineId, EngineRegistrationMetadata, ExecutableEngineRegistrationConfig,
    ExecutionContextIdentity, HardwareClassId, InputIngressContract, InputPlacementContract,
    InputSignatureContract, PreparationOnlyEngineRegistrationConfig, ProviderDeviceIdentity,
    ProviderId, ResidentOutputContract, RuntimeInputContract, StorageClass,
};

struct NonDebugBackend;

fn debug_contract_metadata() -> EngineRegistrationMetadata {
    let engine_id = EngineId::new("debug.contract.engine").expect("valid test engine id");
    let provider = ProviderDeviceIdentity::new(
        ProviderId::new("debug.contract.provider").expect("valid test provider id"),
        "device:0",
    )
    .expect("valid test provider target");
    let hardware = HardwareClassId::new("debug.contract.hardware").expect("valid test hardware");
    let storage = StorageClass::new("debug.contract.storage").expect("valid test storage");
    EngineRegistrationMetadata::new(
        engine_id,
        provider,
        hardware,
        Arc::from([storage.clone()]),
        storage,
        CoreCapabilityBundle::default(),
    )
}

fn debug_contract_ingress() -> InputIngressContract {
    InputIngressContract::new(
        InputPlacementContract::new(|_, _| true),
        InputSignatureContract::new(|_, _, _, _| true),
        RuntimeInputContract::new(|_, _| true),
        ResidentOutputContract::new(|_, _| true),
    )
}

#[test]
fn engine_registration_descriptors_have_public_debug_bounds() {
    fn assert_debug<T: Debug>() {}

    assert_debug::<EngineRegistrationMetadata>();
    assert_debug::<PreparationOnlyEngineRegistrationConfig>();
    assert_debug::<ExecutableEngineRegistrationConfig>();
}

#[test]
fn engine_registration_descriptor_debug_output_is_bounded_and_useful() {
    let metadata = debug_contract_metadata();
    let metadata_debug = format!("{metadata:?}");
    assert!(metadata_debug.contains("EngineRegistrationMetadata"));
    assert!(metadata_debug.contains("debug.contract.engine"));
    assert!(metadata_debug.contains("storage_classes"));
    assert!(metadata_debug.contains("capabilities"));

    let preparation = PreparationOnlyEngineRegistrationConfig::new(
        debug_contract_metadata(),
        ExecutionContextIdentity::of::<()>(),
    );
    let preparation_debug = format!("{preparation:?}");
    assert!(preparation_debug.contains("PreparationOnlyEngineRegistrationConfig"));
    assert!(preparation_debug.contains("metadata"));
    assert!(preparation_debug.contains("context_identity"));

    let executable = ExecutableEngineRegistrationConfig::new(
        metadata,
        ExecutionContextIdentity::of::<NonDebugBackend>(),
        debug_contract_ingress(),
    );
    let executable_debug = format!("{executable:?}");
    assert!(executable_debug.contains("ExecutableEngineRegistrationConfig"));
    assert!(executable_debug.contains("metadata"));
    assert!(executable_debug.contains("context_identity"));
    assert!(executable_debug.contains("ingress_present: true"));
    // The descriptor owns no engine and no driver: it is metadata plus the
    // context identity the run-time engine must report.
    assert!(!executable_debug.contains("backend:"));
    assert!(!executable_debug.contains("cache_owner:"));
}