Struct GkState 

pub struct GkState {
    pub core: EngineCore,
    /* private fields */
}

GK evaluation engine using precomputed per-input dependent lists.

On set_input(), only nodes that depend on the changed input are dirtied. O(affected_nodes) per input change. This is the default engine for production use.

Fields

core: EngineCore

Shared evaluation core (buffers, clean flags, inputs).

Implementations

impl GkState

pub fn set_inputs(&mut self, coords: &[u64])

Set all coordinate inputs at once (convenience for the common single-cycle case). Wraps each u64 as Value::U64 and sets them at indices 0..N with per-input change detection.

pub fn set_input(&mut self, idx: usize, value: Value)

Set a single input by index, dirtying only dependent nodes.

Single-register semantics: a cell-bound slot’s only register IS the cell — set_input writes through the cell. A non-cell slot’s register is the local inputs[idx] array. There’s no second snapshot kept in lockstep with the cell; reads always go to whichever is the slot’s register.

Dependents-marking is the dependent-list invalidation strategy carried by GkState; it’s the write-side half of the engine’s dirty-tracking. Other engines (RawState, ProvScanState) implement different strategies — see their own set_inputs impls.

pub fn get_input(&self, idx: usize) -> Value

Read the value of an input by index.

Single-register read: cell-bound slots return the cell’s current value; non-cell slots return the local register. One canonical value per slot, no stale snapshot.

pub fn read_input_value(&self, idx: usize) -> Value

Alias for Self::get_input; kept for legacy callers that picked the more explicit name. Both read the cell when one is attached.

pub fn attach_shared_cell(&mut self, idx: usize, cell: SharedCell)

Attach a SharedCell to an input slot.

After this call the cell becomes the slot’s sole register: reads via read_input go through the cell, set_input writes through the cell. The local inputs[idx] array entry for this slot is unused for cell-bound slots — there is no second register kept in lockstep.

Dependents are dirtied because the slot’s effective value just changed from the local default to whatever the cell currently holds.

pub fn shared_cell(&self, idx: usize) -> Option<SharedCell>

Returns the SharedCell attached to an input slot, if any. Used by materialize_wiring_from_outer to share an existing cell with inner kernels.

pub fn invalidate_cell_bound_dependents(&mut self)

Mark every node that depends on a cell-bound input slot as dirty. Called at cycle boundary on descendant kernels so that values written into shared cells by ancestor kernels’ advance_broadcasts actually propagate through our memoized eval cone on the next pull.

Without this, a passthrough output node like query — whose wiring is WireSource::Input(idx_of_query_slot) and whose query slot is attached to the phase kernel’s output cell — caches its first-cycle value forever, because no set_input call on this kernel ever touches that slot (the cell is written by the ancestor, not via our set_input).

pub fn reset_inputs_from(&mut self, from_idx: usize)

Reset a range of inputs to their defaults. Used at stanza boundaries to prevent capture leakage across stanzas. from_idx is typically coord_count (skip coordinates, reset only capture inputs).

Cell-bound slots are skipped: the cell is cross-kernel shared state with its own lifecycle (managed by the owning ancestor scope), and a stanza-local reset must not clobber other kernels’ views.

pub fn invalidate_all(&mut self)

Invalidate all state: reset all inputs to defaults and mark every node dirty. Provides “clean slate” semantics.

pub fn pull(&mut self, program: &GkProgram, output_name: &str) -> &Value

Pull a named output variate from the program.

pub fn seed_node_buffer( &mut self, node_idx: usize, port_idx: usize, value: Value, )

Pre-populate a node’s output buffer slot and mark it clean, suppressing on-demand evaluation. Used by the scope-init pass (SRD 11 §“Init Binding Contract” Plan B) to seed per-fiber states with init binding values that the activation kernel already evaluated, so each fiber doesn’t re-fire the eval at first pull.

pub fn node_buffer(&self, node_idx: usize, port_idx: usize) -> Option<&Value>

Read a node’s output buffer slot. Used by the scope-init pass to extract a pre-pulled init binding value from one state and seed it into another.

pub fn pull_by_index( &mut self, program: &GkProgram, output_idx: usize, ) -> &Value

Pull an output by index (declaration order). Only evaluates the computation cone for this specific output.

pub fn pull_all<'a>(&'a mut self, program: &GkProgram) -> Vec<&'a Value>

Pull all outputs in declaration order.

pub fn accessor(program: &GkProgram, names: &[&str]) -> OutputAccessor

Create a memoized accessor for a named subset of outputs. Resolves names to indices once; subsequent access uses indices only.