Struct HybridKernelPushPull 

pub struct HybridKernelPushPull { /* private fields */ }

Hybrid kernel with both push-side per-step skip and pull-side cone guard.

Push side: set_inputs() marks only steps that depend on changed inputs as dirty; clean steps are skipped during eval().

Pull side: eval_for_slot() first checks whether the output’s cone of influence changed at all. If not, the cached value is returned without entering the eval loop.

Implementations

impl HybridKernelPushPull

pub fn coord_count(&self) -> usize

How many inputs are coordinates. (The core’s coord_count field counts the buffer slots all inputs occupy.)

pub fn resolve_output(&self, name: &str) -> Option<usize>

The slot of a named output.

pub fn get_slot(&self, slot: usize) -> u64

Read an output by pre-resolved slot index. Panics on Ref2-colored slots (axiom S2) — use read_vec_*.

pub fn get(&self, name: &str) -> u64

Read a named output variate after eval(). Panics on Ref2-colored outputs (axiom S2) — use read_vec_*.

pub fn get_value(&self, name: &str) -> Value

The named output as a typed Value, decoded by its port type: a Ref2 output is copied out through its pair (compiled_handles.md §4), so the caller never holds a pointer; a slot that holds None reads as None.

pub fn pull_output(&mut self, name: &str) -> Value

A named output, its cone run if a write is pending.

pub fn externs(&self) -> Vec<(&str, PortType)>

The kernel’s externs by name and declared type.

pub fn cursor_schemas(&self) -> &[SourceSchema]

The cursors the program declares, with the partitions the compiler resolved where its over clause and extent were constant, as PolydatProgram::cursor_schemas reports them.

pub fn set_cursor( &mut self, name: &str, partition: &Partition, ) -> Result<(), WriteError>

Narrow a cursor to one partition, as narrow_cursor does on the interpreter: its Ext slot and six scalar projections are set as externs.

pub fn read_vec_f32(&self, slot: usize) -> &[f32]

Borrow a vec_f32 output’s current contents.

pub fn read_vec_f64(&self, slot: usize) -> &[f64]

Borrow a vec_f64 output’s current contents.

pub fn read_vec_f16(&self, slot: usize) -> &[f16]

Borrow a vec_f16 output’s current contents.

pub fn read_vec_i8(&self, slot: usize) -> &[i8]

Borrow a vec_i8 output’s current contents.

pub fn read_vec_i16(&self, slot: usize) -> &[i16]

Borrow a vec_i16 output’s current contents.

pub fn read_vec_i32(&self, slot: usize) -> &[i32]

Borrow a vec_i32 output’s current contents.

pub fn read_vec_i64(&self, slot: usize) -> &[i64]

Borrow a vec_i64 output’s current contents.

pub fn set_input(&mut self, name: &str, value: Value) -> Result<(), WriteError>

Set an extern by name, as PolydatState::set_input does on the interpreter. Every kind is written through at once. Every step downstream of the extern reruns, and the next evaluation runs whatever the cone guard says.

pub fn set_input_at( &mut self, index: usize, value: Value, ) -> Result<(), WriteError>

Self::set_input by input index.

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

Evaluate with push-side step skip (no cone guard): a new round.

pub fn eval_for_slot(&mut self, coords: &[u64], slot: usize) -> u64

Cone guard + push-side skip: the full optimization.

pub fn engine_counts(&self) -> (usize, usize)

The number of native segments and of closure steps in this kernel, in that order: what the per-node engine choice decided.

pub fn retain_nodes(&mut self, nodes: Vec<Box<dyn PolydatNode>>)

Store owned nodes to keep JIT-baked pointers valid.

Trait Implementations

impl Clone for HybridKernelPushPull

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Kernel for HybridKernelPushPull

fn output_names(&self) -> Vec<String>

In declaration order, as the interpreter lists them: the assembler sets them on every compiled kernel.

fn engine(&self) -> Engine

The engine this kernel runs on.

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

Set the coordinate inputs for the next evaluation.

fn set_input(&mut self, name: &str, value: Value) -> Result<(), WriteError>

Set an extern by name. One rule on every engine: the value must satisfy the declared port type (a carrier’s bit-stuffed forms included) or be None, which clears the extern; a value of another type is refused at the write, never healed. A coordinate is set with Self::set_inputs, not here. An unknown name is an error naming the known ones.

fn const_inits(&self) -> &[ConstInit]

The const bindings this kernel initializes, in the order Self::init evaluates them: a const that reads another comes after it.

fn init_input_at( &mut self, index: usize, value: Value, ) -> Result<(), WriteError>

Write an input as part of initialization. It is Self::set_input_at except that a const’s slot is accepted, which is how Self::init stores each const’s value.

fn set_cursor( &mut self, name: &str, partition: &Partition, ) -> Result<(), WriteError>

Narrow a cursor to one partition: its Ext slot and its six scalar projections are set.

fn eval(&mut self)

Evaluate every output for the inputs set so far.

fn pull(&mut self, name: &str) -> Value

The named output for the inputs set so far, evaluating what it needs and no more: the output’s cone, on all four engines (pure native code, though one function, runs only the fusion units of the output’s cone; engines.md §1). A side channel in the cone fires when the output is pulled; a failing node fails when pulled, with the same attributed message on every engine: the node’s name, the outputs it feeds, the program’s context, and its inputs. The value is owned; a handle is never returned to the host, and a slot that holds None reads as None.

fn input_names(&self) -> Vec<String>

Every input by name, the coordinates first.

fn output_type(&self, name: &str) -> Option<PortType>

The declared port type of a named output.

fn externs(&self) -> Vec<(String, PortType)>

The externs by name and declared type.

fn cursor_schemas(&self) -> &[SourceSchema]

The cursors the program declares, with the partitions the compiler resolved where it could.

fn input_value(&self, name: &str) -> Option<Value>

The value of a named input as the kernel holds it now, an extern or a coordinate; None for a name that is not an input.

fn traversals(&self) -> &[Traversal]

The traversals the program declares, in document order.

fn plan(&self) -> EnginePlan

What this kernel’s engine decided for the program: how much of it runs as native segments, as closure steps, and on the interpreter. The one planning detail a kernel exposes.

fn input_index(&self, name: &str) -> Option<usize>

The index of a named input among Self::input_names, the coordinates first: what Self::set_input_at takes.

fn set_input_at(&mut self, index: usize, value: Value) -> Result<(), WriteError>

Self::set_input by index, for a host that binds the same inputs every cycle: the name is resolved once, with Self::input_index, and no lookup runs per write.

fn output_index(&self, name: &str) -> Option<usize>

The index of a named output among Self::output_names: what Self::pull_at takes.

fn pull_at(&mut self, index: usize) -> Value

Self::pull by index, for a host that reads the same outputs every cycle: the name is resolved once, with Self::output_index, and no lookup runs per pull.

fn traverse(&mut self, index: usize) -> Result<TraversalStream, String>

Open the traversal at index against this kernel’s current values (for_traversal.md §3.6): the comprehension’s sources see the wires they reference as this kernel holds them now, and the cascaded wires are snapshotted into every activation. Every engine opens traversals (engines.md §3.6).

fn invalidate_all(&mut self)

Begin the next cycle with nothing current, so every step, a side channel included, runs again when pulled. The runtime model makes a cycle whose inputs did not move cost nothing; this is how a host runs such a cycle anyway, as the polydat binary does when every input is fixed.

fn shared_cells(&self) -> Vec<SharedCellEntry>

The cells this kernel’s shared bindings are bound to (scope model §6): one register per binding, which every kernel holding the cell reads and writes.

fn output_cell(&self, name: &str) -> Option<SharedCell>

The broadcast cell for a computed output, created on the first ask: a descendant that binds its matching input slot to this cell reads the value each of this kernel’s pulls publishes through it, rather than a copy taken once when the descendant was built (cross_fiber_invalidation.md §3.1).

fn output_modifier(&self, name: &str) -> BindingModifier

The binding modifier a named output was declared with — const, shared, final, or none. A binder reads it to decide how a descendant takes the output: a const is effectively fixed for the scope’s life and is value-copied, where a computed output is bound to its broadcast cell (scope_model.md §4).

fn cells_in_scope(&self) -> Vec<SharedCellEntry>

Every cell a descendant of this kernel could bind to: the ones its own shared slots hold, plus the ones it carries forward for a descendant without holding a slot for them itself. The second kind is why an ancestral shared reaches a grandchild whose parent’s program never names it.

fn set_transit_cells(&mut self, cells: Vec<SharedCellEntry>)

Carry cells forward for this kernel’s descendants. The binder writes what the parent had and this kernel holds no slot for.

fn input_port_type(&self, name: &str) -> Option<PortType>

The declared type of a named input slot, coordinates included. The binder reads it to adapt a value the parent supplies into the type the child’s slot declares.

fn bind_input_cell(&mut self, name: &str, cell: SharedCell) -> bool

Bind the named input slot to cell, whether or not the slot was built as a shared register, and answer whether it was bound.

fn attach_shared_cell( &mut self, name: &str, cell: SharedCell, ) -> Result<(), String>

Bind the shared binding name to cell, so this kernel and every other holder of the cell read and write one register: a write on any of them is what the others read next, and a dependent output is recomputed. A name that is not a shared binding is an error naming the ones that are.

fn into_program(self: Box<Self>) -> Arc<dyn KernelProgram>

The program this kernel runs, shareable across threads: each thread creates its own kernel from it with KernelProgram::create_kernel.

fn ledger(&self) -> &Arc<CompileLedger>

The compile ledger of the program tree this kernel belongs to: what compiling it and everything opened from it has built.

fn resources(&self) -> &ResourceScope

The resource scope of the program tree this kernel belongs to: the slot for the host’s ResourceAccessor that every node of the tree looks resources up through. A host that did not hand one to the compile (CompileOptions::resources) installs its accessor here, once; kernels created from or forked off this one, subscopes built under it, and its traversal bodies share the scope.

fn canonical_hash(&self) -> [u8; 32]

The canonical hash of this kernel’s program (scope_model.md §8): equal for one program built on any of the four engines, and for every kernel created from or forked off it, and a function of what the program computes rather than of its source text. What a host keys a checkpoint on.

fn coord_count(&self) -> usize

How many of the inputs are coordinates: they come first in input_names, and set_inputs writes them.

fn input_value_at(&self, index: usize) -> Option<Value>

The value input index holds now: a coordinate’s pending or current value, an extern’s current value. None past the end.

fn input_default_at(&self, index: usize) -> Option<Value>

The value input index starts with: an extern’s declared default, U64(0) for a coordinate. None past the end.

fn input_is_cell_bound(&self, index: usize) -> bool

Whether input index is bound to a shared cell, so that its value is the cell’s and a reset leaves it alone.

fn reset_inputs(&mut self)

Every input that is not a coordinate and not bound to a cell back at its default, and whatever depends on a changed one not current. What a host does at a boundary where values written for the last stretch must not leak into the next.

fn fork(&self) -> Box<dyn Kernel>

A new kernel over the same program with this kernel’s state: its inputs, its current outputs, and its cells, which stay shared (a cell is the scope’s register, not a value it holds), transit cells included. Callable concurrently on a kernel shared across threads (native_scope_trees.md §4).

fn publish_broadcasts(&mut self)

Pull every output a descendant bound to by cell, so the descendant reads the current value. Nothing happens on a kernel nothing is bound under. A failing output is left for the pull that needs it to report.

fn commit_write_throughs(&mut self) -> Result<(), String>

Commit the Rule 2 write-throughs: pull each synthetic __write_<name> output and write it through the cell of the shared binding it exports to. No-op for a kernel without them.

fn program_id(&self) -> ProgramId

The identity of this kernel’s program: equal for kernels created from one program and for forks, different for any two programs, the same program compiled twice included. What a host seals a plan of pre-resolved indices against.

fn input_type_origin(&self, name: &str) -> Option<TypeOrigin>

How input name’s type was established: written by the author, or inferred by the compiler and so open to CompileOptions::input_variance (input_variance.md §3). A host that compiles many scopes at Info reports each open input once from here rather than from every compile’s log.

fn init(&mut self) -> Result<(), KernelError>

Initialize the kernel: evaluate every const binding once, in dependency order, and store its value for the rest of the kernel’s life.

fn traverse_all(&mut self) -> Result<Vec<TraversalStream>, String>

Open every traversal, in document order.

fn scope_coordinates(&self) -> &[ScopeCoord]

This kernel’s place in the comprehension nest its scope was built under, outermost last: a child’s path is its own followed by its parent’s. Empty for a root, which is every kernel a host compiles rather than binds, so the compiled engines answer empty until one is bound under a parent.

fn extend_scope_coordinates(&mut self, _outer: &[ScopeCoord])

Append outer to this kernel’s own scope-coordinate path, which the binder does once the child’s inputs are in. A no-op on an engine that keeps no path.

fn instance_hash(&self, ancestors: &[&dyn Kernel]) -> [u8; 32]

The instance hash of this kernel’s program under ancestors, innermost first (scope_model.md §8.2): what PolydatProgram::instance_hash gives for the same programs, whichever engines the kernels are on.

fn is_equivalent_to(&self, other: &dyn Kernel) -> bool

Whether other runs the same program (scope_model.md §8.3): their canonical hashes are equal, whichever engines the two are on.

fn is_subset_of(&self, parent: &dyn Kernel) -> bool

Whether this kernel’s program adds nothing parent’s does not already supply (scope_model.md §8.3): it is equivalent to parent, or it outputs nothing but its own inputs and every input it declares parent declares too. The answer PolydatProgram::is_subset_of gives for the same programs, on any engines.

fn as_interpreter(&self) -> Option<&PolydatKernel>

The interpreter’s kernel, when this is one: what a caller that needs the interpreter’s own extras (Metadata, Dataflow, its program and state) reaches them through. None on a compiled engine.

fn as_interpreter_mut(&mut self) -> Option<&mut PolydatKernel>

Self::as_interpreter, mutably.

impl SlotKernel for HybridKernelPushPull

fn resolve_output(&self, name: &str) -> Option<usize>

The buffer slot a named output writes, resolved once so a caller reading the same output every cycle pays no lookup.

fn get_slot(&self, slot: usize) -> u64

The raw u64 in slot, as it stands: no evaluation, no decoding. Panics on a Ref2 slot (axiom S2), which has no scalar to read — use the read_vec_* borrows.

fn get(&self, name: &str) -> u64

Self::get_slot by output name.

fn get_value(&self, name: &str) -> Value

A named output decoded by its port type, a Ref2 output copied out through its pair so the caller never holds a pointer. Reads what is there; Kernel::pull evaluates first.

fn eval_for_slot(&mut self, coords: &[u64], slot: usize) -> u64

Set the coordinates, evaluate what slot needs, and return its raw u64. The whole read in one call and one u64, which is what a tier benchmark wants: pull_at gives the same value through a Value it has to construct.

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

Set the coordinates and run every step, the whole program in one call. Kernel::eval is the same evaluation over coordinates already written with set_inputs; this is the form that takes them, which is what a loop over a coordinate range wants.

fn read_vec_f32(&self, slot: usize) -> &[f32]

Borrow a vec_f32 output’s current contents. The borrow ties to &self, so holding one across the next evaluation is a compile error rather than a stale read (axiom S2).

fn read_vec_f64(&self, slot: usize) -> &[f64]

Borrow a vec_f64 output’s current contents.

fn read_vec_f16(&self, slot: usize) -> &[f16]

Borrow a vec_f16 output’s current contents.

fn read_vec_i8(&self, slot: usize) -> &[i8]

Borrow a vec_i8 output’s current contents.

fn read_vec_i16(&self, slot: usize) -> &[i16]

Borrow a vec_i16 output’s current contents.

fn read_vec_i32(&self, slot: usize) -> &[i32]

Borrow a vec_i32 output’s current contents.

fn read_vec_i64(&self, slot: usize) -> &[i64]

Borrow a vec_i64 output’s current contents.