Enum DfOperator 

pub enum DfOperator {
    Compute {
        op: ComputeOp,
        inputs: Vec<ChannelId>,
        output: ChannelId,
    },
    Memory {
        op: MemoryOp,
        address: ChannelId,
        data: ChannelId,
        ordering: Vec<ChannelId>,
    },
    Steer {
        decider: ChannelId,
        data: ChannelId,
        true_out: ChannelId,
        false_out: ChannelId,
    },
    Stream {
        start: ChannelId,
        step: ChannelId,
        bound: ChannelId,
        output: ChannelId,
        done: ChannelId,
    },
    Carry {
        initial: ChannelId,
        feedback: ChannelId,
        continue_signal: ChannelId,
        output: ChannelId,
    },
    CarryGate {
        inner: ChannelId,
        outer: ChannelId,
        level: ChannelId,
        output: ChannelId,
    },
    Merge {
        inputs: Vec<ChannelId>,
        output: ChannelId,
    },
    Split {
        input: ChannelId,
        outputs: Vec<ChannelId>,
    },
    Constant {
        value: TokenValue,
        output: ChannelId,
        repeat: Option<u64>,
    },
    Source {
        external_id: u32,
        output: ChannelId,
    },
    Sink {
        input: ChannelId,
        external_id: u32,
    },
    Select {
        selector: ChannelId,
        inputs: Vec<ChannelId>,
        output: ChannelId,
    },
    Reduce {
        op: ComputeOp,
        initial: ChannelId,
        values: ChannelId,
        count_or_done: ChannelId,
        output: ChannelId,
    },
}

A dataflow operator that fires when all inputs are ready

Variants

Compute

Pure computation: inputs → output

Fields

op: ComputeOp

inputs: Vec<ChannelId>

output: ChannelId

Memory

Memory access with ordering constraints

Fields

op: MemoryOp

address: ChannelId

Address input

data: ChannelId

Data input (for stores) or output (for loads)

ordering: Vec<ChannelId>

Ordering dependencies (must complete before this fires)

Steer

Steer: conditional routing (RipTide’s key control-flow primitive)

Routes data to one of two outputs based on a boolean decider. This enables control flow without traditional branches.

Fields

decider: ChannelId

Boolean condition channel

data: ChannelId

Value to route

true_out: ChannelId

Output when decider is true

false_out: ChannelId

Output when decider is false

Stream

Stream: fused loop induction variable

This is RipTide’s key optimization - fusing the induction variable computation (i = 0; i < N; i++) into a single operator. Achieves 27-52% operator count reduction.

Fields

start: ChannelId

Starting value

step: ChannelId

Step/increment

bound: ChannelId

Upper bound

output: ChannelId

Current value output (fires once per iteration)

done: ChannelId

Done signal (true when loop complete)

Carry

Carry: loop-carried dependency

Handles values that flow from one iteration to the next.

Fields

initial: ChannelId

Initial value (first iteration)

feedback: ChannelId

Feedback from previous iteration

continue_signal: ChannelId

Continue signal (false = loop done)

output: ChannelId

Output value

CarryGate

CarryGate: multi-level loop support

Selects between tokens from inner and outer loops.

Fields

inner: ChannelId

Inner loop token

outer: ChannelId

Outer loop token

level: ChannelId

Level selector

output: ChannelId

Output

Merge

Merge: join divergent control paths

Combines tokens from multiple paths into a single stream. Used for ordering at control flow join points.

Fields

inputs: Vec<ChannelId>

output: ChannelId

Split

Split: fan-out to multiple consumers

Fields

input: ChannelId

outputs: Vec<ChannelId>

Constant

Constant: emit a constant value

Fields

value: TokenValue

output: ChannelId

repeat: Option<u64>

How many times to emit (None = once)

Source

Source: external input to the graph

Fields

external_id: u32

External ID for this input

output: ChannelId

Sink

Sink: external output from the graph

Fields

input: ChannelId

external_id: u32

External ID for this output

Select

Select: multiplexer (choose one of N inputs based on selector)

Fields

selector: ChannelId

Selector (index into inputs)

inputs: Vec<ChannelId>

Input channels

output: ChannelId

Output

Reduce

Reduce: accumulate values (for reductions like sum, product)

Fields

op: ComputeOp

Reduction operation

initial: ChannelId

Initial/identity value

values: ChannelId

Stream of values to reduce

count_or_done: ChannelId

Count of values (or done signal)

output: ChannelId

Final result

Implementations

impl DfOperator

pub fn inputs(&self) -> Vec<ChannelId>

Get all input channels for this operator

pub fn outputs(&self) -> Vec<ChannelId>

Get all output channels for this operator

pub fn energy_cost(&self) -> u32

Estimated energy cost for this operator

pub fn is_control(&self) -> bool

Is this a control-flow operator?

Trait Implementations

impl Clone for DfOperator

fn clone(&self) -> DfOperator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DfOperator

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

Formats the value using the given formatter.