Struct ComputationGraphStore 

pub struct ComputationGraphStore { /* private fields */ }

CID-linked computation graph store.

Maintains the directed acyclic graph (DAG) of ComputationNodes that constitutes the forward pass. After forward execution each node is linked to its output CID; after the backward pass each node carries a gradient CID. The graph can be checkpointed to bytes and restored for resume.

Implementations

impl ComputationGraphStore

pub fn new() -> Self

Create an empty computation graph store.

pub fn add_node(&mut self, node: ComputationNode)

Insert a node into the graph.

Edges are automatically derived from node.input_cids: for each input CID we look for an existing node whose output_cid matches, and record a directed edge from that producer node to the new node.

pub fn record_output( &mut self, node_id: &str, output_cid: String, ) -> Result<(), GradientError>

Record that the forward pass for node_id produced output_cid.

After recording, edges to any downstream nodes that list this CID as an input are added automatically.

pub fn record_gradient( &mut self, node_id: &str, grad_cid: String, ) -> Result<(), GradientError>

Record that the backward pass computed a gradient for node_id.

pub fn topological_order(&self) -> Vec<String>

Return node IDs in topological order (Kahn’s algorithm).

Nodes with no predecessors come first; this is the correct execution order for the forward pass (and reverse for backward).

pub fn store_gradient_as_arrow( &mut self, node_id: &str, gradient_data: &[f32], shape: &[usize], ) -> Result<String, GradientError>

Serialize a gradient tensor as an Apache Arrow IPC block and store its CID in the named node’s gradient_cid field.

The gradient data is wrapped in an crate::arrow::ArrowTensorStore as a single f32 column named "gradient". Shape metadata is embedded in the Arrow field metadata so it survives a round-trip through Self::load_gradient_from_arrow.

The CID is computed as a DAG-CBOR CID (SHA-256) over the raw Arrow IPC bytes, matching the convention used throughout ipld_codec.

Returns

The CID string that was recorded on the node.

pub fn load_gradient_from_arrow( arrow_bytes: &[u8], expected_shape: &[usize], ) -> Result<Vec<f32>, GradientError>

Decode gradient data from raw Arrow IPC block bytes.

Validates that the decoded tensor shape matches expected_shape before returning the f32 values. Pass an empty expected_shape slice to skip shape validation.

pub fn checkpoint(&self) -> Result<Vec<u8>, GradientError>

Serialize the entire graph to JSON bytes for checkpointing.

pub fn from_checkpoint(data: &[u8]) -> Result<Self, GradientError>

Restore a graph from checkpoint bytes produced by Self::checkpoint.

pub fn find_consumers(&self, cid: &str) -> Vec<&ComputationNode>

Return all nodes that list cid as one of their input CIDs.

pub fn provenance_chain(&self, output_cid: &str) -> Vec<&ComputationNode>

Return the chain of nodes whose output_cid led to output_cid being produced, ordered from earliest producer to the node that emitted it.

This performs a depth-first traversal of the reverse DAG starting from the node that owns output_cid.

pub fn get_node(&self, node_id: &str) -> Option<&ComputationNode>

Immutable access to a node by id.

pub fn node_count(&self) -> usize

Number of nodes currently in the graph.

pub fn edge_count(&self) -> usize

Number of edges currently in the graph.

pub fn nodes(&self) -> impl Iterator<Item = &ComputationNode>

Iterate over all nodes (order is unspecified).

Trait Implementations

impl Clone for ComputationGraphStore

fn clone(&self) -> ComputationGraphStore

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ComputationGraphStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ComputationGraphStore

fn default() -> ComputationGraphStore

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ComputationGraphStore

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ComputationGraphStore

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.