bb-ops 0.3.4

Canonical concrete components for the bytesandbrains framework — syscalls, wire transport, backends, protocols, role implementations.
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

//! Lifecycle + bootstrap ops. //!
//! Spec: Sub-D in `docs/IR_AND_DSL.md` §5a.
//!
//! - `LifecyclePhase(phase: int) → Trigger` - fires when
//!   `Engine::fire_lifecycle(phase)` is called.
//! - `BootstrapDispatch() → cmd` - mints a CommandId.
//! - `BootstrapOutput(cmd) → Trigger` - awaits completion of the
//!   matching CommandId.

use bb_ir::proto::onnx::NodeProto;
use bb_runtime::atomic::DispatchResult;
use bb_runtime::bus::OpError;
use bb_runtime::ids::CommandId;
use bb_runtime::runtime::RuntimeResourceRef;
use bb_runtime::slot_value::SlotValue;
use bb_runtime::syscall::values::{CommandIdValue, TriggerValue};

const DOMAIN: &str = "ai.bytesandbrains.syscall";

/// Marker struct for dispatch_table TypeId keying.
pub struct LifecyclePhaseOp;

/// `LifecyclePhase(phase: string) → Trigger`. Phase-gated firing is
/// enforced by the engine: only ops enrolled in
/// `Engine.lifecycle_table[phase]` are pushed onto the frontier when
/// `fire_lifecycle(phase)` runs, so this body only needs to emit the
/// trigger when invoked. `Node` is the named consumer
/// of `Engine::register_lifecycle_op`, parsing each node's `phase`
/// attribute at install time.
pub fn invoke_lifecycle_phase(
    _node: &NodeProto,
    _inputs: &[(&str, &dyn SlotValue)],
    _ctx: &mut RuntimeResourceRef<'_>,
) -> Result<DispatchResult, OpError> {
    Ok(DispatchResult::Immediate(vec![(
        "trigger".to_string(),
        Box::new(TriggerValue),
    )]))
}

/// Marker struct for dispatch_table TypeId keying.
pub struct BootstrapDispatchOp;

/// `BootstrapDispatch() → cmd`.
pub fn invoke_bootstrap_dispatch(
    _node: &NodeProto,
    _inputs: &[(&str, &dyn SlotValue)],
    ctx: &mut RuntimeResourceRef<'_>,
) -> Result<DispatchResult, OpError> {
    let cmd = ctx.allocate_command_id();
    Ok(DispatchResult::Immediate(vec![(
        "cmd".to_string(),
        Box::new(CommandIdValue(bb_runtime::ids::CommandId::from(
            cmd.as_u64(),
        ))),
    )]))
}

/// Marker struct for dispatch_table TypeId keying.
pub struct BootstrapOutputOp;

/// `BootstrapOutput(cmd) → Trigger`. Awaits the matching
/// `BootstrapDispatch`'s `CommandId`. Reads the upstream `cmd`
/// input (a `CommandIdValue`) and returns
/// `DispatchResult::Async(cmd_id)` - the engine parks the op in
/// `pending_async[cmd_id]` until the host completes the command
/// via the ingress queue.
pub fn invoke_bootstrap_output(
    _node: &NodeProto,
    inputs: &[(&str, &dyn SlotValue)],
    _ctx: &mut RuntimeResourceRef<'_>,
) -> Result<DispatchResult, OpError> {
    let cmd_handle = inputs
        .iter()
        .find(|(name, _)| *name == "cmd")
        .map(|(_, h)| *h)
        .ok_or_else(|| OpError {
            detail: "BootstrapOutput: missing `cmd` input".into(),
            ..Default::default()
        })?;
    let cmd = cmd_handle
        .as_any()
        .downcast_ref::<CommandIdValue>()
        .ok_or_else(|| OpError {
            detail: "BootstrapOutput: `cmd` input is not a CommandIdValue".into(),
            ..Default::default()
        })?;
    Ok(DispatchResult::Async(CommandId::new(cmd.0.as_u64())))
}

#[cfg(test)]
#[path = "tests.rs"]
mod tests;

/// Linker-anchor - see `bb_ops::link_force` for details.
pub fn link_force() {
    use std::hint::black_box;
    black_box(invoke_lifecycle_phase as usize);
    black_box(invoke_bootstrap_dispatch as usize);
    black_box(invoke_bootstrap_output as usize);
}

use bb_runtime::registry::OpRegistration as _BbOpsSyscallReg;

inventory::submit! {
    _BbOpsSyscallReg {
        domain: DOMAIN,
        op_type: "LifecyclePhase",
        invoke: invoke_lifecycle_phase,
        kind: bb_runtime::registry::RegistrationKind::Syscall,
    }
}

inventory::submit! {
    _BbOpsSyscallReg {
        domain: DOMAIN,
        op_type: "BootstrapDispatch",
        invoke: invoke_bootstrap_dispatch,
        kind: bb_runtime::registry::RegistrationKind::Syscall,
    }
}

inventory::submit! {
    _BbOpsSyscallReg {
        domain: DOMAIN,
        op_type: "BootstrapOutput",
        invoke: invoke_bootstrap_output,
        kind: bb_runtime::registry::RegistrationKind::Syscall,
    }
}