Graph

DAG

The representation of the graph as a set of Nodes.

Operations can be applied on it using push_operation! and reverted using pop_operation! like a stack. To get the set of possible operations, use get_operations. The members of the object should not be manually accessed, instead always use the provided interface functions.

DAG()

Construct and return an empty DAG.

PossibleOperations

A struct storing all possible operations on a DAG. To get the PossibleOperations on a DAG, use get_operations.

PossibleOperations()

Construct and return an empty PossibleOperations object.

can_pop(graph::DAG)

Return true if pop_operation! is possible, false otherwise.

pop_operation!(graph::DAG)

Revert the latest applied operation on the graph.

See also: DAG, push_operation!

push_operation!(graph::DAG, operation::Operation)

Apply a new operation to the graph.

See also: DAG, pop_operation!

reset_graph!(graph::DAG)

Reset the graph to its initial state with no operations applied.

in(edge::Edge, graph::DAG)

Check whether the edge is part of the graph.

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

Check whether the node is part of the graph.

_insert_edge!(graph::DAG, node1::Node, node2::Node, index::Int=0; track = true, invalidate_cache = true)

Insert the edge between node1 (child) and node2 (parent) into the graph. An optional integer index can be given. The arguments of the function call that this node compiles to will then be ordered by these indices.

Keyword Arguments

• track::Bool: Whether to add the changes to the DAG's Diff. Should be set false in parsing or graph creation functions for performance.
• invalidate_cache::Bool: Whether to invalidate caches associated with the changes. Should also be turned off for graph creation or parsing.

See also: _insert_node!, _remove_node!, _remove_edge!

_insert_node!(graph::DAG, node::Node; track = true, invalidate_cache = true)

Insert the node into the graph.

Keyword Arguments

track::Bool: Whether to add the changes to the DAG's Diff. Should be set false in parsing or graph creation functions for performance.

invalidate_cache::Bool: Whether to invalidate caches associated with the changes. Should also be turned off for graph creation or parsing.

See also: _remove_node!, _insert_edge!, _remove_edge!

_remove_edge!(graph::DAG, node1::Node, node2::Node; track = true, invalidate_cache = true)

Remove the edge between node1 (child) and node2 (parent) into the graph. Returns the integer index of the removed edge.

Keyword Arguments

• track::Bool: Whether to add the changes to the DAG's Diff. Should be set false in parsing or graph creation functions for performance.
• invalidate_cache::Bool: Whether to invalidate caches associated with the changes. Should also be turned off for graph creation or parsing.

See also: _insert_node!, _remove_node!, _insert_edge!

_remove_node!(graph::DAG, node::Node; track = true, invalidate_cache = true)

Remove the node from the graph.

Keyword Arguments

track::Bool: Whether to add the changes to the DAG's Diff. Should be set false in parsing or graph creation functions for performance.

invalidate_cache::Bool: Whether to invalidate caches associated with the changes. Should also be turned off for graph creation or parsing.

See also: _insert_node!, _insert_edge!, _remove_edge!

get_snapshot_diff(graph::DAG)

Return the graph's Diff since last time this function was called.

See also: revert_diff!, AppliedOperation and revert_operation!

insert_edge!(graph::DAG, node1::Node, node2::Node)

Insert the edge between node1 (child) and node2 (parent) into the graph.

insert_node!(graph::DAG, node::Node)
insert_node!(graph::DAG, task::AbstractTask, name::String="")

Insert the node into the graph or alternatively construct a node from the given task and insert it.

invalidate_caches!(graph::DAG, operation::NodeReduction)

Invalidate the operation caches for a given NodeReduction.

This deletes the operation from the graph's possible operations and from the involved nodes' own operation caches.

invalidate_caches!(graph::DAG, operation::NodeSplit)

Invalidate the operation caches for a given NodeSplit.

This deletes the operation from the graph's possible operations and from the involved nodes' own operation caches.

invalidate_operation_caches!(graph::DAG, node::ComputeTaskNode)

Invalidate the operation caches of the given node through calls to the respective invalidate_caches! functions.

invalidate_operation_caches!(graph::DAG, node::DataTaskNode)

Invalidate the operation caches of the given node through calls to the respective invalidate_caches! functions.

show(io::IO, graph::DAG)

Print the given graph to io. If there are too many nodes it will print only a summary of them.

show_nodes(io::IO, graph::DAG)

Print a graph's nodes. Should only be used for small graphs as it prints every node in a list.

get_entry_nodes(graph::DAG)

Return a vector of the graph's entry nodes.

get_exit_node(graph::DAG)

Return the graph's exit node. This assumes the graph only has a single exit node. If the graph has multiple exit nodes, the one encountered first will be returned.

get_properties(graph::DAG)

Return the graph's GraphProperties.

operation_stack_length(graph::DAG)

Return the number of operations applied to the graph.

is_connected(graph::DAG)

Return whether the given graph is connected.

is_scheduled(graph::DAG)

Validate that the entire graph has been scheduled, i.e., every ComputeTaskNode has its .device set.

is_valid(graph::DAG)

Validate the entire graph using asserts. Intended for testing with @assert is_valid(graph).