Node

ComputeTaskNode <: Node

Any node that computes a result from inputs using an AbstractComputeTask.

Fields

.task: The node's compute task type. A concrete subtype of AbstractComputeTask.
.parents: A vector of the node's parents (i.e. nodes that depend on this one).
.children: A vector of tuples with the node's children (i.e. nodes that this one depends on) and their index, used to order the arguments for the AbstractComputeTask.
.id: The node's id. Improves the speed of comparisons and is used as a unique identifier.

DataTaskNode <: Node

Any node that transfers data and does no computation.

Fields

.task: The node's data task type. Usually DataTask.
.parents: A vector of the node's parents (i.e. nodes that depend on this one).
.children: A vector of tuples of the node's children (i.e. nodes that this one depends on) and their indices, indicating their order in the resulting function call passed to the task.
.id: The node's id. Improves the speed of comparisons and is used as a unique identifier.
.name: The name of this node for entry nodes into the graph (is_entry_node) to reliably assign the inputs to the correct nodes when executing.

Edge

Type of an edge in the graph. Edges can only exist between a DataTaskNode and a ComputeTaskNode or vice versa, not between two of the same type of node.

An edge always points from child to parent: child = e.edge[1] and parent = e.edge[2]. Additionally, the Edgecontains theindex` which is used as the child's index in the parent node.

The child is the prerequisite node of the parent.

Node

The abstract base type of every node.

See DataTaskNode, ComputeTaskNode and make_node.

make_edge(n1::ComputeTaskNode, n2::DataTaskNode, index::Int)

Construct and return a new Edge pointing from n1 (child) to n2 (parent).

The index parameter is 0 by default and is passed to the parent node as argument index for its child.

make_edge(n1::Node, n2::Node, index::Int)

Fallback implementation of make_edge throwing an error. If you got this error it likely means you tried to construct an edge between two nodes of the same type.

make_edge(n1::DataTaskNode, n2::ComputeTaskNode)

Construct and return a new Edge pointing from n1 (child) to n2 (parent).

The index parameter is 0 by default and is passed to the parent node as argument index for its child.

make_node(t::AbstractDataTask)

Construct and return a new DataTaskNode with the given task.

make_node(t::AbstractComputeTask)

Construct and return a new ComputeTaskNode with the given task.

make_node(t::AbstractTask)

Fallback implementation of make_node for an AbstractTask, throwing an error.

==(e1::Edge, e2::Edge)

Equality comparison between two edges.

==(n1::Node, n2::Node)

Fallback equality comparison between two nodes. For equal node types, the more specific versions of this function will be called.

==(n1::ComputeTaskNode, n2::ComputeTaskNode)

Equality comparison between two ComputeTaskNodes.

==(n1::DataTaskNode, n2::DataTaskNode)

Equality comparison between two DataTaskNodes.

children(dag::DAG, node::Node)

Return node's children.

A node's children are its prerequisite nodes, nodes that need to execute before the task of this node.

A node's children are the nodes that must run before it.

is_child(dag::DAG, potential_child::Node, node::Node)

Return whether the potential_child is a child of node.

is_entry_node(node::Node)

Return whether this node is an entry node in its graph, i.e., it has no children.

is_exit_node(node::Node)

Return whether this node is an exit node of its graph, i.e., it has no parents.

is_parent(dag::DAG, potential_parent::Node, node::Node)

Return whether the potential_parent is a parent of node.

parents(dag::DAG, node::Node)

Return the node's parents.

A node's parents are its subsequent nodes, nodes that need this node to execute.

partners(dag::DAG, node::Node, set::Set{Node})

Alternative version to partners(node::Node), avoiding allocation of a new set. Works on the given set and returns nothing.

partners(dag::DAG, node::Node)

Return a vector of all partners of this node.

A node's partners are all parents of any of its children. The result contains no duplicates and includes the node itself.

siblings(dag::DAG, node::Node)

Return a vector of all siblings of this node.

A node's siblings are all children of any of its parents. The result contains no duplicates and includes the node itself.

task(node::Node)

Return the node's task.

show(io::IO, e::Edge)

Print a short string representation of the edge to io.

show(io::IO, n::Node)

Print a short string representation of the node to io.

to_var_name(id::UUID)

Return the uuid as a string usable as a variable name in code generation.