Struct Graph 

pub struct Graph { /* private fields */ }

Graph is dagrs’s main body.

[‘Graph’] is a network that satisfies FBP logic, provides node dependencies, and runs all of its nodes completely asynchronously A Graph contains multiple nodes, which can be added as long as they implement the Node trait. Each node defines specific execution logic by implementing the [Action] trait and overriding the run method.

The execution process of a Graph proceeds as follows:

• The user creates a set of nodes, each implementing the Node trait. These nodes can be created programmatically or Generate auto_node using parse.
• Dependencies between nodes are defined, creating a directed acyclic graph (DAG) structure.
• During execution, nodes communicate via input/output channels (InChannel and OutChannel). These channels support both point-to-point communication (using MPSC) and broadcasting (using Broadcast).
• After all nodes complete their execution, marking the graph as inactive. This ensures that the Graph cannot be executed again without resetting its state.

The Graph is designed to efficiently manage task execution with built-in fault tolerance and flexible scheduling.

Implementations

impl Graph

pub fn new() -> Graph

Constructs a new Graph

pub fn reset(&mut self)

Reset the graph state but keep the nodes.

pub fn add_node(&mut self, node: impl Node + 'static)

Adds a new node to the Graph

pub fn add_edge(&mut self, from_id: NodeId, all_to_ids: Vec<NodeId>)

Adds an edge between two nodes in the Graph. If the outgoing port of the sending node is empty and the number of receiving nodes is > 1, use the broadcast channel An MPSC channel is used if the outgoing port of the sending node is empty and the number of receiving nodes is equal to 1 If the outgoing port of the sending node is not empty, adding any number of receiving nodes will change all relevant channels to broadcast

pub fn start(&mut self) -> Result<(), GraphError>

This function is used for the execution of a single dag.

pub fn check_loop_and_partition(&mut self) -> bool

Checks for cycles in the abstract graph, and partitions the graph into blocks.

• Groups nodes into blocks, creating a new block whenever a conditional node / loop is encountered

Returns true if the graph contains a cycle, false otherwise.

pub fn get_results<T>(&self) -> HashMap<NodeId, Option<Arc<T>>>

where T: Send + Sync + 'static,

Get the output of all tasks.

pub fn get_outputs(&self) -> HashMap<NodeId, Output>

pub fn set_env(&mut self, env: EnvVar)

Before the dag starts executing, set the dag’s global environment variable.