eredu-runtime 0.3.0

Backend-neutral model execution runtime for Eredu
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
141
142
143
144
145
146

//! Shared admission, immutable installation and bounded observer forwarding.
use super::*;
use std::sync::Arc;

/// Revalidates exact retained session capabilities before shared geometry/budget
/// traversal. Callers first validate native execution-mode facts and capture support.
pub fn validate_session(
    capture: &AdmittedCapturePlan,
    plan: &AdmittedInterventionPlan,
    discovery: &InterventionDiscovery,
    estimator: &dyn InterventionEstimator,
) -> Result<(), CaptureError> {
    validate_continuation(
        capture,
        plan,
        discovery,
        estimator,
        0,
        CaptureUsage::default(),
    )
}

pub(crate) fn validate_continuation(
    capture: &AdmittedCapturePlan,
    plan: &AdmittedInterventionPlan,
    discovery: &InterventionDiscovery,
    estimator: &dyn InterventionEstimator,
    next_prediction: u64,
    inherited: CaptureUsage,
) -> Result<(), CaptureError> {
    if plan.request().batch != 1 {
        return Err(CaptureError::Unsupported(
            "interventions require single-sequence text generation".into(),
        ));
    }
    let checked = plan
        .plan()
        .clone()
        .admit(discovery, plan.request(), plan.session_id())?;
    if checked.identity() != plan.identity() {
        return Err(CaptureError::Invalid(
            "intervention admission differs from loaded source/session capabilities".into(),
        ));
    }
    preflight_continuation(capture, &checked, estimator, next_prediction, inherited)
}

/// Installs one immutable run after validation. Both capture-only and combined
/// plans obey the same replacement rule; empty runs keep the ordinary fast path.
pub fn install_session(
    slot: &mut Option<CaptureSession>,
    capture: AdmittedCapturePlan,
    intervention: Option<(AdmittedInterventionPlan, Arc<dyn InterventionEstimator>)>,
) -> Result<(), CaptureError> {
    if slot.is_some() {
        return Err(CaptureError::Invalid(
            "capture/intervention plan already installed".into(),
        ));
    }
    if capture.is_empty()
        && intervention
            .as_ref()
            .is_none_or(|(plan, _)| plan.is_empty())
    {
        return Ok(());
    }
    let mut session = CaptureSession::new(capture);
    if let Some((plan, estimator)) = intervention {
        session.enable_interventions(plan, estimator)?;
    }
    *slot = Some(session);
    Ok(())
}

/// Borrows the existing capture owner. Backends provide native primitives and a
/// typed error conversion; this adapter owns no completion or native recovery state.
pub struct CaptureObserver<'a, B, F> {
    session: &'a mut CaptureSession,
    backend: B,
    map_error: F,
}
impl<'a, B, F> CaptureObserver<'a, B, F> {
    /// Creates an observer that forwards all value/control hooks to the shared run.
    pub fn new(session: &'a mut CaptureSession, backend: B, map_error: F) -> Self {
        Self {
            session,
            backend,
            map_error,
        }
    }
}
impl<B, E, F> crate::ActivationObserver<B::Tensor, E> for CaptureObserver<'_, B, F>
where
    B: InterventionBackend,
    F: Fn(CaptureExecutionError<B::Error>) -> E,
{
    fn observe(&mut self, path: &str, value: &B::Tensor) -> Result<(), E> {
        self.session
            .observe(&mut self.backend, path, value)
            .map_err(&self.map_error)
    }
    fn intervene(&mut self, path: &str, value: &B::Tensor) -> Result<Option<B::Tensor>, E> {
        self.session
            .intervene(&mut self.backend, path, value)
            .map_err(&self.map_error)
    }
    fn routing_control(
        &mut self,
        path: &str,
        rows: u64,
    ) -> Result<Option<eredu_nn::routing_intervention::GroupSelectionControl>, E> {
        self.session
            .routing_control(path, rows)
            .map_err(|error| (self.map_error)(error.into()))
    }
    fn routing_applied(
        &mut self,
        path: &str,
        original: Option<crate::RoutingDecision<'_, B::Tensor>>,
        effective: crate::RoutingDecision<'_, B::Tensor>,
    ) -> Result<(), E> {
        self.session
            .routing_applied(&mut self.backend, path, original, effective)
            .map_err(&self.map_error)
    }
    fn routing_failed(&mut self, path: &str, message: &str) {
        self.session.routing_failed(path, message);
    }
    fn finish(&mut self) -> Result<(), E> {
        self.session
            .finish_interventions()
            .map_err(|error| (self.map_error)(error.into()))
    }
    fn observe_routing(
        &mut self,
        routing: crate::RoutingObservation<'_, B::Tensor>,
    ) -> Result<(), E> {
        let mut result = Ok(());
        routing.for_each_tensor(|path, value| {
            if result.is_ok() {
                result = self.observe(&path, value);
            }
        });
        result
    }
}