Struct HybridKernelRaw 

pub struct HybridKernelRaw { /* private fields */ }

Hybrid kernel with no provenance tracking.

Every eval() call runs all steps unconditionally. Useful as a baseline and for graphs where inputs change on every evaluation.

Implementations

impl HybridKernelRaw

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

Evaluate all hybrid steps unconditionally: a new round.

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

Set an extern by name, as PolydatState::set_input does on the interpreter. Every run evaluates everything, so it takes effect at the next run.

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

Self::set_input by input index.

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<(), String>

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 eval_for_slot(&mut self, coords: &[u64], slot: usize) -> u64

Eval all steps and return the value at slot.

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

Read a named output after eval(). Panics on Ref2 slots (axiom S2) — use read_vec_*.

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

Read by slot index. Panics on Ref2 slots (axiom S2) — use read_vec_*.

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 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.

pub fn coord_count(&self) -> usize

Number of coordinate inputs.

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 resolve_output(&self, name: &str) -> Option<usize>

Resolve an output name to its buffer slot.

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 HybridKernelRaw

fn clone(&self) -> HybridKernelRaw

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Kernel for HybridKernelRaw

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<(), String>

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 set_cursor( &mut self, name: &str, partition: &Partition, ) -> Result<(), String>

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 the interpreter, the closure tier, and the hybrid kernel alike (pure native code, being one function, evaluates the program). 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<(), String>

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 (SRD 113 §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. On every engine (engine parity, step 8).

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 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 traverse_all(&mut self) -> Result<Vec<TraversalStream>, String>

Open every traversal, in document order.