Struct TestPipelineStd 

pub struct TestPipelineStd<SrcClk: PlatformClock + Send + 'static> { /* private fields */ }

Concrete std graph using ConcurrentEdge (Arc-backed, Clone+Send+Sync).

Mirrors the output of a concurrent(true) codegen invocation. Ingress edges are not stored: occupancy and policy are obtained from the source node at runtime, matching codegen output exactly.

Implementations

impl<SrcClk: PlatformClock + Send + 'static> TestPipelineStd<SrcClk>

pub fn new( node_0: impl Into<SourceNode<TestCounterSourceTensor<SrcClk, 32>, TestTensor, 1>>, node_1: TestIdentityModelNodeTensor<TEST_MAX_BATCH>, node_2: impl Into<SinkNode<TestSinkNodeTensor, TestTensor, 1>>, q_1: ConcurrentEdge, q_2: ConcurrentEdge, mgr_1: ConcurrentMemoryManager<TestTensor>, mgr_2: ConcurrentMemoryManager<TestTensor>, ) -> Self

Construct a new concurrent graph instance.

Mirrors the new(..) constructor emitted by codegen for a concurrent(true) graph. Ingress probe edges are not created here — ingress occupancy and policy are read directly from the source node.

Trait Implementations

impl<SrcClk: PlatformClock + Send + 'static> GraphApi<3, 3> for TestPipelineStd<SrcClk>

fn get_node_descriptors(&self) -> [NodeDescriptor; 3]

Returns the static descriptors for all nodes in the graph.

fn get_edge_descriptors(&self) -> [EdgeDescriptor; 3]

Returns the static descriptors for all edges in the graph.

fn get_node_policies(&self) -> [NodePolicy; 3]

Returns the static NodePolicy for every node in the graph.

fn get_edge_policies(&self) -> [EdgePolicy; 3]

Returns the static EdgePolicy for every edge in the graph.

fn edge_occupancy_for<const E: usize>( &self, ) -> Result<EdgeOccupancy, GraphError>

Returns a one-shot occupancy snapshot for edge E.

fn write_all_edge_occupancies( &self, out: &mut [EdgeOccupancy; 3], ) -> Result<(), GraphError>

Write current occupancy for all edges into out.

fn refresh_occupancies_for_node<const I: usize, const IN: usize, const OUT: usize>( &self, out: &mut [EdgeOccupancy; 3], ) -> Result<(), GraphError>

Partial refresh: update only entries for edges incident to node I.

fn step_node_by_index<C, T>( &mut self, index: usize, clock: &C, telemetry: &mut T, ) -> Result<StepResult, NodeError>

where EdgePolicy: Copy, C: PlatformClock + Sized, T: Telemetry + Sized,

Drives a single scheduling step for the node at index.

fn validate_graph(&self) -> Result<(), GraphError>

Validates the graph topology and policies derived from node and edge descriptors.

fn node_policy_for<const I: usize, const IN: usize, const OUT: usize>( &self, ) -> NodePolicy

where Self: GraphNodeAccess<I> + GraphNodeTypes<I, IN, OUT>, <Self as GraphNodeAccess<I>>::Node: Node<IN, OUT, <Self as GraphNodeTypes<I, IN, OUT>>::InP, <Self as GraphNodeTypes<I, IN, OUT>>::OutP>,

Returns the static NodePolicy for node I (compile-time index).

impl<SrcClk: PlatformClock + Send + 'static> GraphEdgeAccess<1> for TestPipelineStd<SrcClk>

type Edge = EdgeLink<ConcurrentEdge>

The concrete edge type at index E.

fn edge_ref(&self) -> &Self::Edge

Immutable access to the edge at index E.

fn edge_mut(&mut self) -> &mut Self::Edge

Mutable access to the edge at index E.

impl<SrcClk: PlatformClock + Send + 'static> GraphEdgeAccess<2> for TestPipelineStd<SrcClk>

type Edge = EdgeLink<ConcurrentEdge>

The concrete edge type at index E.

fn edge_ref(&self) -> &Self::Edge

Immutable access to the edge at index E.

fn edge_mut(&mut self) -> &mut Self::Edge

Mutable access to the edge at index E.

impl<SrcClk: PlatformClock + Send + 'static> GraphNodeAccess<0> for TestPipelineStd<SrcClk>

type Node = NodeLink<SourceNode<TestCounterSourceTensor<SrcClk, 32>, Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>, 1>, 0, 1, (), Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>>

The concrete node type at index I.

fn node_ref(&self) -> &Self::Node

Immutable access to the node at index I.

fn node_mut(&mut self) -> &mut Self::Node

Mutable access to the node at index I.

impl<SrcClk: PlatformClock + Send + 'static> GraphNodeAccess<1> for TestPipelineStd<SrcClk>

type Node = NodeLink<InferenceModel<TestTensorBackend, Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>, Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>, TEST_MAX_BATCH>, 1, 1, Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>, Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>>

The concrete node type at index I.

fn node_ref(&self) -> &Self::Node

Immutable access to the node at index I.

fn node_mut(&mut self) -> &mut Self::Node

Mutable access to the node at index I.

impl<SrcClk: PlatformClock + Send + 'static> GraphNodeAccess<2> for TestPipelineStd<SrcClk>

type Node = NodeLink<SinkNode<TestSinkNodeTensor, Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>, 1>, 1, 0, Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>, ()>

The concrete node type at index I.

fn node_ref(&self) -> &Self::Node

Immutable access to the node at index I.

fn node_mut(&mut self) -> &mut Self::Node

Mutable access to the node at index I.

impl<SrcClk: PlatformClock + Send + 'static> GraphNodeContextBuilder<0, 0, 1> for TestPipelineStd<SrcClk>

where Self: GraphNodeAccess<0, Node = NodeLink<SourceNode<TestCounterSourceTensor<SrcClk, 32>, TestTensor, 1>, 0, 1, (), TestTensor>>,

fn make_step_context<'graph, 'telemetry, 'clock, C, T>( &'graph mut self, clock: &'clock C, telemetry: &'telemetry mut T, ) -> StepContext<'graph, 'telemetry, 'clock, 0, 1, <Self as GraphNodeTypes<0, 0, 1>>::InP, <Self as GraphNodeTypes<0, 0, 1>>::OutP, <Self as GraphNodeTypes<0, 0, 1>>::InQ, <Self as GraphNodeTypes<0, 0, 1>>::OutQ, <Self as GraphNodeTypes<0, 0, 1>>::InM, <Self as GraphNodeTypes<0, 0, 1>>::OutM, C, T>

where EdgePolicy: Copy, C: PlatformClock + Sized, T: Telemetry + Sized,

Construct a StepContext for node I.

fn with_node_and_step_context<'telemetry, 'clock, C, T, R, E>( &mut self, clock: &'clock C, telemetry: &'telemetry mut T, f: impl FnOnce(&mut <Self as GraphNodeAccess<0>>::Node, &mut StepContext<'_, 'telemetry, 'clock, 0, 1, <Self as GraphNodeTypes<0, 0, 1>>::InP, <Self as GraphNodeTypes<0, 0, 1>>::OutP, <Self as GraphNodeTypes<0, 0, 1>>::InQ, <Self as GraphNodeTypes<0, 0, 1>>::OutQ, <Self as GraphNodeTypes<0, 0, 1>>::InM, <Self as GraphNodeTypes<0, 0, 1>>::OutM, C, T>) -> Result<R, E>, ) -> Result<R, E>

where Self: GraphNodeAccess<0>, EdgePolicy: Copy, C: PlatformClock + Sized, T: Telemetry + Sized,

Borrowed handoff: in one &mut self borrow, lend both &mut node(I) and a fully wired StepContext to a closure. This avoids overlapping &mut borrows escaping the call.

impl<SrcClk: PlatformClock + Send + 'static> GraphNodeContextBuilder<1, 1, 1> for TestPipelineStd<SrcClk>

where Self: GraphNodeAccess<1, Node = NodeLink<TestIdentityModelNodeTensor<TEST_MAX_BATCH>, 1, 1, TestTensor, TestTensor>>,

fn make_step_context<'graph, 'telemetry, 'clock, C, T>( &'graph mut self, clock: &'clock C, telemetry: &'telemetry mut T, ) -> StepContext<'graph, 'telemetry, 'clock, 1, 1, <Self as GraphNodeTypes<1, 1, 1>>::InP, <Self as GraphNodeTypes<1, 1, 1>>::OutP, <Self as GraphNodeTypes<1, 1, 1>>::InQ, <Self as GraphNodeTypes<1, 1, 1>>::OutQ, <Self as GraphNodeTypes<1, 1, 1>>::InM, <Self as GraphNodeTypes<1, 1, 1>>::OutM, C, T>

where EdgePolicy: Copy, C: PlatformClock + Sized, T: Telemetry + Sized,

Construct a StepContext for node I.

fn with_node_and_step_context<'telemetry, 'clock, C, T, R, E>( &mut self, clock: &'clock C, telemetry: &'telemetry mut T, f: impl FnOnce(&mut <Self as GraphNodeAccess<1>>::Node, &mut StepContext<'_, 'telemetry, 'clock, 1, 1, <Self as GraphNodeTypes<1, 1, 1>>::InP, <Self as GraphNodeTypes<1, 1, 1>>::OutP, <Self as GraphNodeTypes<1, 1, 1>>::InQ, <Self as GraphNodeTypes<1, 1, 1>>::OutQ, <Self as GraphNodeTypes<1, 1, 1>>::InM, <Self as GraphNodeTypes<1, 1, 1>>::OutM, C, T>) -> Result<R, E>, ) -> Result<R, E>

where Self: GraphNodeAccess<1>, EdgePolicy: Copy, C: PlatformClock + Sized, T: Telemetry + Sized,

Borrowed handoff: in one &mut self borrow, lend both &mut node(I) and a fully wired StepContext to a closure. This avoids overlapping &mut borrows escaping the call.

impl<SrcClk: PlatformClock + Send + 'static> GraphNodeContextBuilder<2, 1, 0> for TestPipelineStd<SrcClk>

where Self: GraphNodeAccess<2, Node = NodeLink<SinkNode<TestSinkNodeTensor, TestTensor, 1>, 1, 0, TestTensor, ()>>,

fn make_step_context<'graph, 'telemetry, 'clock, C, T>( &'graph mut self, clock: &'clock C, telemetry: &'telemetry mut T, ) -> StepContext<'graph, 'telemetry, 'clock, 1, 0, <Self as GraphNodeTypes<2, 1, 0>>::InP, <Self as GraphNodeTypes<2, 1, 0>>::OutP, <Self as GraphNodeTypes<2, 1, 0>>::InQ, <Self as GraphNodeTypes<2, 1, 0>>::OutQ, <Self as GraphNodeTypes<2, 1, 0>>::InM, <Self as GraphNodeTypes<2, 1, 0>>::OutM, C, T>

where EdgePolicy: Copy, C: PlatformClock + Sized, T: Telemetry + Sized,

Construct a StepContext for node I.

fn with_node_and_step_context<'telemetry, 'clock, C, T, R, E>( &mut self, clock: &'clock C, telemetry: &'telemetry mut T, f: impl FnOnce(&mut <Self as GraphNodeAccess<2>>::Node, &mut StepContext<'_, 'telemetry, 'clock, 1, 0, <Self as GraphNodeTypes<2, 1, 0>>::InP, <Self as GraphNodeTypes<2, 1, 0>>::OutP, <Self as GraphNodeTypes<2, 1, 0>>::InQ, <Self as GraphNodeTypes<2, 1, 0>>::OutQ, <Self as GraphNodeTypes<2, 1, 0>>::InM, <Self as GraphNodeTypes<2, 1, 0>>::OutM, C, T>) -> Result<R, E>, ) -> Result<R, E>

where Self: GraphNodeAccess<2>, EdgePolicy: Copy, C: PlatformClock + Sized, T: Telemetry + Sized,

Borrowed handoff: in one &mut self borrow, lend both &mut node(I) and a fully wired StepContext to a closure. This avoids overlapping &mut borrows escaping the call.

impl<SrcClk: PlatformClock + Send + 'static> GraphNodeTypes<0, 0, 1> for TestPipelineStd<SrcClk>

type InP = ()

Payload type for messages consumed by the node.

type OutP = Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>

Payload type for messages produced by the node.

type InQ = NoQueue

Queue type used for input ports.

type OutQ = ConcurrentEdge

Queue type used for output ports.

type InM = StaticMemoryManager<(), 1>

Memory manager type for input ports.

type OutM = ConcurrentMemoryManager<Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>>

Memory manager type for output ports.

impl<SrcClk: PlatformClock + Send + 'static> GraphNodeTypes<1, 1, 1> for TestPipelineStd<SrcClk>

type InP = Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>

Payload type for messages consumed by the node.

type OutP = Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>

Payload type for messages produced by the node.

type InQ = ConcurrentEdge

Queue type used for input ports.

type OutQ = ConcurrentEdge

Queue type used for output ports.

type InM = ConcurrentMemoryManager<Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>>

Memory manager type for input ports.

type OutM = ConcurrentMemoryManager<Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>>

Memory manager type for output ports.

impl<SrcClk: PlatformClock + Send + 'static> GraphNodeTypes<2, 1, 0> for TestPipelineStd<SrcClk>

type InP = Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>

Payload type for messages consumed by the node.

type OutP = ()

Payload type for messages produced by the node.

type InQ = ConcurrentEdge

Queue type used for input ports.

type OutQ = NoQueue

Queue type used for output ports.

type InM = ConcurrentMemoryManager<Tensor<u32, TEST_TENSOR_ELEMENT_COUNT, 2>>

Memory manager type for input ports.

type OutM = StaticMemoryManager<(), 1>

Memory manager type for output ports.

impl<SrcClk: PlatformClock + Clone + Send + Sync + 'static> ScopedGraphApi<3, 3> for TestPipelineStd<SrcClk>

where SourceNode<TestCounterSourceTensor<SrcClk, 32>, TestTensor, 1>: Send, ConcurrentEdge: ScopedEdge, ConcurrentMemoryManager<TestTensor>: ScopedManager<TestTensor>,

fn run_scoped<C, T, S>(&mut self, clock: C, telemetry: T, scheduler: S)

where C: PlatformClock + Clone + Send + Sync + 'static, T: Telemetry + Clone + Send + 'static, S: WorkerScheduler + 'static,

Run the graph concurrently with scheduler-controlled workers.