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.
.nodeReduction: Either this node's NodeReduction or missing, if none. There can only be at most one.
.nodeSplit: Either this node's NodeSplit or missing, if none. There can only be at most one.
.device: The Device this node has been scheduled on by a Scheduler.

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.
.nodeReduction: Either this node's NodeReduction or missing, if none. There can only be at most one.
.nodeSplit: Either this node's NodeSplit or missing, if none. There can only be at most one.
.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::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_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_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(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(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(potential_parent::Node, node::Node)

Return whether the potential_parent is a parent of node.

parents(node::Node)

Return the node's parents.

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

partners(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(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(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.

is_valid(graph::DAG, node::ComputeTaskNode)

Verify that the given compute node is valid in the graph. Call with @assert or @test when testing or debugging.

This also calls is_valid_node(graph::DAG, node::Node).

is_valid(graph::DAG, node::DataTaskNode)

Verify that the given compute node is valid in the graph. Call with @assert or @test when testing or debugging.

This also calls is_valid_node(graph::DAG, node::Node).

is_valid_node(graph::DAG, node::Node)

Verify that a given node is valid in the graph. Call like @test is_valid_node(g, n). Uses @assert to fail if something is invalid but also provide an error message.

This function is very performance intensive and should only be used when testing or debugging.

See also this function's specific versions for the concrete Node types is_valid(graph::DAG, node::ComputeTaskNode) and is_valid(graph::DAG, node::DataTaskNode).