Utility

_lt_node_tuples(n1::Tuple{Node, Int}, n2::Tuple{Node, Int})

Less-Than comparison between nodes with indices.

bytes_to_human_readable(bytes)

Return a human readable string representation of the given number.

julia> using ComputableDAGs

julia> ComputableDAGs.bytes_to_human_readable(4096)
"4.0 KiB"

lower(schedule::Vector{Node}, machine::Machine)

After schedule_dag has made a schedule of nodes, this function lowers the vector of Nodes and AbstractDevices into a vector of FunctionCalls.

sort_node!(node::Node)

Sort the nodes' parents and children vectors. The vectors are mostly very short so sorting does not take a lot of time. Sorted nodes are required to make the finding of NodeReductions a lot faster using the NodeTrie data structure.

unroll_symbol_vector(vec::Vector{Symbol})

Return the given vector as single String without quotation marks or brackets.

NodeIdTrie

Helper struct for NodeTrie. After the Trie's first level, every Trie level contains the vector of nodes that had children up to that level, and the TrieNode's children by UUID of the node's children.

NodeIdTrie()

Constructor for an empty NodeIdTrie.

NodeTrie

Trie data structure for node reduction, inserts nodes by children. Assumes that given nodes have ordered vectors of children (see sort_node!). First insertion level is the node's own task type + name and thus does not have a value (every node has a task type).

See also: insert! and collect

NodeTrie()

Constructor for an empty NodeTrie.

collect(trie::NodeTrie)

Return all sets of at least 2 Nodes that have accumulated in leaves of the trie.

insert!(trie::NodeTrie, node::Node)

Insert the given node into the trie. It's sorted by its type in the first layer, then by its children in the following layers.

collect_helper(trie::NodeIdTrie, acc::Set{Vector{Node}})

Collects the Vectors of this NodeIdTrie node and all its children and puts them in the acc argument.

insert_helper!(trie::NodeIdTrie, node::Node, depth::Int)

Insert the given node into the trie. The depth is used to iterate through the trie layers, while the function calls itself recursively until it ran through all children of the node.