Trait DfirBuilder 

pub trait DfirBuilder {
    // Required methods
    fn singleton_intermediates(&self) -> bool;
    fn add_dfir_at(
        &mut self,
        location: &LocationId,
        dfir: DfirCode,
        operator_tag: Option<&str>,
    );
    fn add_tick_source(
        &mut self,
        location: &LocationId,
        source_rhs: TokenStream,
        out_ident: &Ident,
        replay_each_tick: bool,
        operator_tag: Option<&str>,
    );
    fn batch(
        &mut self,
        in_ident: Ident,
        in_location: &LocationId,
        in_kind: &CollectionKind,
        out_ident: &Ident,
        out_location: &LocationId,
        op_meta: &HydroIrOpMetadata,
        fold_hooked_idents: &HashSet<String>,
    );
    fn yield_from_tick(
        &mut self,
        in_ident: Ident,
        in_location: &LocationId,
        in_kind: &CollectionKind,
        out_ident: &Ident,
        out_location: &LocationId,
    );
    fn unwindow_for_consume(
        &mut self,
        in_ident: Ident,
        in_location: &LocationId,
        out_location: &LocationId,
    ) -> Ident;
    fn begin_atomic(
        &mut self,
        in_ident: Ident,
        in_location: &LocationId,
        in_kind: &CollectionKind,
        out_ident: &Ident,
        out_location: &LocationId,
        op_meta: &HydroIrOpMetadata,
    );
    fn end_atomic(
        &mut self,
        in_ident: Ident,
        in_location: &LocationId,
        in_kind: &CollectionKind,
        out_ident: &Ident,
    );
    fn observe_nondet(
        &mut self,
        trusted: bool,
        location: &LocationId,
        in_ident: Ident,
        in_kind: &CollectionKind,
        out_ident: &Ident,
        out_kind: &CollectionKind,
        op_meta: &HydroIrOpMetadata,
    );
    fn merge_ordered(
        &mut self,
        location: &LocationId,
        first_ident: Ident,
        second_ident: Ident,
        out_ident: &Ident,
        in_kind: &CollectionKind,
        op_meta: &HydroIrOpMetadata,
        operator_tag: Option<&str>,
    );
    fn create_network(
        &mut self,
        from: &LocationId,
        to: &LocationId,
        input_ident: Ident,
        out_ident: &Ident,
        serialize: Option<&DebugExpr>,
        sink: Expr,
        source: Expr,
        deserialize: Option<&DebugExpr>,
        external_element_type: Option<&Type>,
        tag_id: StmtId,
        networking_info: &NetworkingInfo,
    );
    fn create_external_source(
        &mut self,
        on: &LocationId,
        source_expr: Expr,
        out_ident: &Ident,
        deserialize: Option<&DebugExpr>,
        tag_id: StmtId,
    );
    fn create_external_output(
        &mut self,
        on: &LocationId,
        sink_expr: Expr,
        input_ident: &Ident,
        serialize: Option<&DebugExpr>,
        tag_id: StmtId,
    );
    fn emit_fold_hook(
        &mut self,
        location: &LocationId,
        in_ident: &Ident,
        in_kind: &CollectionKind,
        op_meta: &HydroIrOpMetadata,
    ) -> Option<Ident>;
    fn assert_is_consistent(
        &mut self,
        trusted: bool,
        location: &LocationId,
        in_ident: Ident,
        out_ident: &Ident,
    );
    fn observe_for_mut(
        &mut self,
        location: &LocationId,
        in_ident: Ident,
        in_kind: &CollectionKind,
        out_ident: &Ident,
        op_meta: &HydroIrOpMetadata,
    );
    fn create_versioned_network_fork(
        &mut self,
        channel_id: u32,
        dest: &LocationId,
        senders: Vec<(LocationId, Ident, Option<DebugExpr>)>,
        external_element_type: Option<&Type>,
        tag_id: StmtId,
    );
    fn create_versioned_network(
        &mut self,
        channel_id: u32,
        source: &LocationId,
        dest: &LocationId,
        out_ident: &Ident,
        deserialize: Option<&DebugExpr>,
        external_element_type: Option<&Type>,
        tag_id: StmtId,
    );

    // Provided methods
    fn tick_state_lifetime(&self, _op_location: &LocationId) -> TokenStream { ... }
    fn cross_tick_state_lifetime(
        &self,
        _op_location: &LocationId,
    ) -> TokenStream { ... }
}

Available on crate feature build only.

A trait that abstracts over elements of DFIR code-gen that differ between production deployment and simulations.

In particular, this lets the simulator fuse together all locations into one DFIR graph, spit out separate graphs for each tick, and emit hooks for controlling non-deterministic operators.

Required Methods

fn singleton_intermediates(&self) -> bool

Whether the representation of singletons should include intermediate states.

fn add_dfir_at( &mut self, location: &LocationId, dfir: DfirCode, operator_tag: Option<&str>, )

Adds the DFIR statements to the graph for the given location.

The location determines which DFIR graph the statements are placed in (for production, the graph of the location’s root; for simulation, either the fused async graph or the tick’s separate graph). In the future (#2902), production codegen will also use the location to place tick-located statements inside the tick’s loop { ... } context.

fn add_tick_source( &mut self, location: &LocationId, source_rhs: TokenStream, out_ident: &Ident, replay_each_tick: bool, operator_tag: Option<&str>, )

Emits a source operator (e.g. source_iter(...)) that logically lives inside a tick.

• source_rhs is the source pipeline (the right-hand side of the = assignment, e.g. source_iter([123])).
• replay_each_tick selects whether the value is re-emitted on every tick/firing (persisted) or delivered only on the first tick/firing.

The default (simulation) emission places the source directly in the tick’s own graph. Production overrides this since DFIR sources must be at the root level, outside of the tick’s loop { ... } context: it emits the source at the root and windows it into the loop.

fn batch( &mut self, in_ident: Ident, in_location: &LocationId, in_kind: &CollectionKind, out_ident: &Ident, out_location: &LocationId, op_meta: &HydroIrOpMetadata, fold_hooked_idents: &HashSet<String>, )

fn yield_from_tick( &mut self, in_ident: Ident, in_location: &LocationId, in_kind: &CollectionKind, out_ident: &Ident, out_location: &LocationId, )

fn unwindow_for_consume( &mut self, in_ident: Ident, in_location: &LocationId, out_location: &LocationId, ) -> Ident

Un-windows an ident when it is produced inside a tick’s loop { ... } context (in_location) but is about to be consumed by an operator emitted at a location (out_location) outside that loop. Returns the ident to use downstream.

This is needed for operators (e.g. HydroNode::ReduceKeyedWatermark) where the generated code must sit inside a logical tick, while the output is not in a tick, and so we need this method.

fn begin_atomic( &mut self, in_ident: Ident, in_location: &LocationId, in_kind: &CollectionKind, out_ident: &Ident, out_location: &LocationId, op_meta: &HydroIrOpMetadata, )

fn end_atomic( &mut self, in_ident: Ident, in_location: &LocationId, in_kind: &CollectionKind, out_ident: &Ident, )

fn observe_nondet( &mut self, trusted: bool, location: &LocationId, in_ident: Ident, in_kind: &CollectionKind, out_ident: &Ident, out_kind: &CollectionKind, op_meta: &HydroIrOpMetadata, )

fn merge_ordered( &mut self, location: &LocationId, first_ident: Ident, second_ident: Ident, out_ident: &Ident, in_kind: &CollectionKind, op_meta: &HydroIrOpMetadata, operator_tag: Option<&str>, )

fn create_network( &mut self, from: &LocationId, to: &LocationId, input_ident: Ident, out_ident: &Ident, serialize: Option<&DebugExpr>, sink: Expr, source: Expr, deserialize: Option<&DebugExpr>, external_element_type: Option<&Type>, tag_id: StmtId, networking_info: &NetworkingInfo, )

fn create_external_source( &mut self, on: &LocationId, source_expr: Expr, out_ident: &Ident, deserialize: Option<&DebugExpr>, tag_id: StmtId, )

fn create_external_output( &mut self, on: &LocationId, sink_expr: Expr, input_ident: &Ident, serialize: Option<&DebugExpr>, tag_id: StmtId, )

fn emit_fold_hook( &mut self, location: &LocationId, in_ident: &Ident, in_kind: &CollectionKind, op_meta: &HydroIrOpMetadata, ) -> Option<Ident>

Optionally emit a fold hook that buffers and permutes inputs before the fold. Returns the new input ident to use for the fold if a hook was emitted.

fn assert_is_consistent( &mut self, trusted: bool, location: &LocationId, in_ident: Ident, out_ident: &Ident, )

Inserts necessary code to validate a manual assertion that at this point the input live collection is consistent. In production, this is a no-op, but in simulation this will (not yet implemented) inject assertions that validate consistency.

fn observe_for_mut( &mut self, location: &LocationId, in_ident: Ident, in_kind: &CollectionKind, out_ident: &Ident, op_meta: &HydroIrOpMetadata, )

Observes non-determinism introduced by a mut closure operating on a non-strict (unordered / at-least-once) input. In production this is identity; in simulation it delegates to observe_nondet with the strict output kind.

fn create_versioned_network_fork( &mut self, channel_id: u32, dest: &LocationId, senders: Vec<(LocationId, Ident, Option<DebugExpr>)>, external_element_type: Option<&Type>, tag_id: StmtId, )

fn create_versioned_network( &mut self, channel_id: u32, source: &LocationId, dest: &LocationId, out_ident: &Ident, deserialize: Option<&DebugExpr>, external_element_type: Option<&Type>, tag_id: StmtId, )

Provided Methods

fn tick_state_lifetime(&self, _op_location: &LocationId) -> TokenStream

The DFIR persistence lifetime for operator state scoped to a single tick, for an operator at op_location.

Returns 'tick. In the future (#2902), production codegen will emit tick regions as DFIR loop { ... } blocks, where this must instead be 'none when op_location is a tick.

fn cross_tick_state_lifetime(&self, _op_location: &LocationId) -> TokenStream

The DFIR persistence lifetime for operator state that accumulates across ticks, for an operator at op_location.

Returns 'static. In the future (#2902), production codegen will emit tick regions as DFIR loop { ... } blocks, where this must instead be 'loop when op_location is a tick.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl DfirBuilder for ProdDfirBuilder