Enum brane_ast::ast::Edge

pub enum Edge {
    Node {
        task: usize,
        locs: Locations,
        at: Option<Location>,
        input: HashMap<DataName, Option<AvailabilityKind>>,
        result: Option<String>,
        metadata: HashSet<Metadata>,
        next: usize,
    },
    Linear {
        instrs: Vec<EdgeInstr>,
        next: usize,
    },
    Stop {},
    Branch {
        true_next: usize,
        false_next: Option<usize>,
        merge: Option<usize>,
    },
    Parallel {
        branches: Vec<usize>,
        merge: usize,
    },
    Join {
        merge: MergeStrategy,
        next: usize,
    },
    Loop {
        cond: usize,
        body: usize,
        next: Option<usize>,
    },
    Call {
        input: HashSet<DataName>,
        result: HashSet<DataName>,
        next: usize,
    },
    Return {
        result: HashSet<DataName>,
    },
}

Defines an Edge (i.e., an intelligent control-flow operation) in the Workflow graph.

Is also referred to as an ‘Edge’ for historical reasons and because almost all of the elements are edge variants. In fact, the only Node is ‘Node’, which is why the rest doesn’t explicitly mentions it being an edge.

The edges can be thought of as a linked list of statements. However, each statement may secretly group multiple statements (instrucitons) to make reasoning about the graph easier.

Finally, the developers would like to formally apologize for completely butchering the term ‘Edge’.

Variants

Node

A Node is an edge that runs a task. It has one input edge and one output edge.

Fields

task: usize

The task to call

locs: Locations

An additional list that may or may not restrict locations.

at: Option<Location>

Annotation about where the task will be run. This is not meant to be populated by anyone except the planner.

input: HashMap<DataName, Option<AvailabilityKind>>

Reference to any input datasets/results that might be input to this node together with how they might be accessed. This latter part is populated during planning.

result: Option<String>

Reference to the result if this call generates one.

metadata: HashSet<Metadata>

Metadata for this call

next: usize

The next edge to execute (usually the next one)

Linear

A Linear edge is simple a series of instructions that are run, after which is goes to one new edge.

Fields

instrs: Vec<EdgeInstr>

The series of instructions to execute.

next: usize

The next edge to execute (usually the next one)

Stop

A Stop is an edge that stops execution.

Branch

A Branching edge is an edge that branches into two possible (but disjoint) based on the result of a series of instructions.

Stack layout

• Requires a boolean to be on top of the stack.

Fields

true_next: usize

The next edge to run if the condition returned ‘true’. Is not relative to the current program counter (i.e., if 0 is given, the first branch in the program is executed).

false_next: Option<usize>

The next edge to run if the condition returned ‘false’. Is not relative to the current program counter (i.e., if 0 is given, the first branch in the program is executed).

merge: Option<usize>

The location where the branches will join together if the Branch does not fully return. This is only here for analysis purposes; it’s not used by the VM.

Parallel

A Parallel edge is an edge that branches into multiple branches that are all taken simultaneously.

Fields

branches: Vec<usize>

The edges that kickoff each branch. Is not relative to the current program counter (i.e., if 0 is given, then the first branch in the program is executed).

merge: usize

The location where the branches will merge together. This is only here for analysis purposes; it’s not used by the VM.

Join

A Join edge is an edge that joins multiple branches into one, waiting until all have been completed.

Note that the execution of the join-edge acts like a fence, so is quite non-trivial.

Fields

merge: MergeStrategy

Defines the merge strategy of the Join, i.e., how to combine the results of the branches together.

next: usize

The next edge to execute (usually the next one)

Loop

Repeats a given set of edges indefinitely.

Fields

cond: usize

The edges that compute the condition.

body: usize

The edges that are repeated for as long as the condition returns ‘true’.

next: Option<usize>

The next edge to execute after the loop has been completed (usually the next one). Note, however, that this may be empty if the loop fully returns.

Call

A Calling edge is one that re-uses edges by executing the given edge instead. When done, the ‘next’ edge is pushed on the frame stack and popped when a Return edge is executed.

Stack layout

• Requires a Function object to be on top of the stack which will be called.
• Requires N arguments of arbitrary type, where N is equal to the function object’s arity. The first argument of the function is at the bottom, the last second-to-top on the stack.

Fields

input: HashSet<DataName>

Reference to any input datasets/results that might be input to this node.

result: HashSet<DataName>

Reference to the result (or dataset) if this call generates one.

next: usize

The next edge to execute (usually the next one)

Return

A Returning edge is one that returns from a called edge by popping the next from the call stack.

Stack layout

• Optionally requires a value to be on the stack of the called function’s return type. Whether or not this is need and which type that value has is determined by the top value on the frame stack.

Fields

result: HashSet<DataName>

If this return returns a value and that value is a Data, then this names which it is.

Trait Implementations

impl Clone for Edge

fn clone(&self) -> Edge

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Edge

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Edge

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EnumDebug for Edge

fn type_name() -> &'static str

Returns the static name of the type used for EnumDebug-printing.

fn variant_names() -> &'static [&'static str]

Returns all variants in the trait as a list of names.

fn variant_name(&self) -> &'static str

Returns the static name of the variant.

fn variant(&self) -> EnumDebugFormatter<'_, Self>

Returns a formatter for this enum that writes its variant name.

fn variants() -> Copied<Iter<'static, &'static str>>

Returns an iterator over all variants in this enum.

impl Serialize for Edge

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.