ferrum-interfaces 0.8.4

Core trait contracts for the Ferrum LLM inference engine
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

use serde::Serialize;
use std::collections::{BTreeMap, BTreeSet};

use super::{
    canonical_fingerprint, invalid_event, validate_sha256, DeviceId, ExecutionPlan, NodeId,
    OperationId, PlanHash, PlanId, ProviderId, VNextError,
};
use crate::vnext::ProviderExecutionSemantics;

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct TrustedNodeTopology {
    pub(super) operation_id: OperationId,
    pub(super) provider_id: ProviderId,
    pub(super) provider_execution_semantics: ProviderExecutionSemantics,
    pub(super) dependencies: BTreeSet<NodeId>,
}

impl TrustedNodeTopology {
    pub fn operation_id(&self) -> &OperationId {
        &self.operation_id
    }

    pub fn provider_id(&self) -> &ProviderId {
        &self.provider_id
    }

    pub const fn provider_execution_semantics(&self) -> ProviderExecutionSemantics {
        self.provider_execution_semantics
    }

    pub fn dependencies(&self) -> &BTreeSet<NodeId> {
        &self.dependencies
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct TrustedExecutionTopology {
    plan_id: PlanId,
    plan_hash: PlanHash,
    device_id: DeviceId,
    device_runtime_implementation_fingerprint: String,
    pub(super) nodes: BTreeMap<NodeId, TrustedNodeTopology>,
    #[serde(skip)]
    fingerprint: String,
}

impl TrustedExecutionTopology {
    pub fn from_plan(plan: &ExecutionPlan) -> Result<Self, VNextError> {
        let mut nodes = BTreeMap::new();
        for node in plan.payload().nodes() {
            if nodes
                .insert(
                    node.id().clone(),
                    TrustedNodeTopology {
                        operation_id: node.operation_id().clone(),
                        provider_id: node.selection().selected_provider().clone(),
                        provider_execution_semantics: node.provider_execution_semantics(),
                        dependencies: node.dependencies().iter().cloned().collect(),
                    },
                )
                .is_some()
            {
                return Err(invalid_event("trusted plan has duplicate node ids"));
            }
        }
        if nodes.is_empty() {
            return Err(invalid_event("trusted execution topology is empty"));
        }
        let mut topology = Self {
            plan_id: plan.payload().plan_id().clone(),
            plan_hash: plan.plan_hash().clone(),
            device_id: plan.payload().device_id().clone(),
            device_runtime_implementation_fingerprint: plan
                .payload()
                .device_runtime_implementation_fingerprint()
                .to_owned(),
            nodes,
            fingerprint: String::new(),
        };
        validate_sha256(
            &topology.device_runtime_implementation_fingerprint,
            "topology runtime implementation fingerprint",
        )?;
        topology.fingerprint = canonical_fingerprint(&topology);
        Ok(topology)
    }

    pub fn plan_id(&self) -> &PlanId {
        &self.plan_id
    }

    pub fn plan_hash(&self) -> &PlanHash {
        &self.plan_hash
    }

    pub fn device_id(&self) -> &DeviceId {
        &self.device_id
    }

    pub fn device_runtime_implementation_fingerprint(&self) -> &str {
        &self.device_runtime_implementation_fingerprint
    }

    pub fn fingerprint(&self) -> &str {
        &self.fingerprint
    }

    pub fn node_ids(&self) -> BTreeSet<NodeId> {
        self.nodes.keys().cloned().collect()
    }

    pub fn node(&self, node_id: &NodeId) -> Option<&TrustedNodeTopology> {
        self.nodes.get(node_id)
    }
}