Struct CompiledKernelRaw 

pub struct CompiledKernelRaw { /* private fields */ }

The closure tier with no provenance: every evaluation runs every step.

Implementations

impl CompiledKernelRaw

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

Evaluate every step for coords: a new round.

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

Eval + return a specific slot. No cone guard — always evaluates.

pub fn coord_count(&self) -> usize

The coordinate inputs.

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 set_input(&mut self, name: &str, value: Value) -> Result<(), String>

Set an extern by name, as PolydatState::set_input does on the interpreter. The value must be of the declared port type. Every kind is written through at once, and every step downstream of the extern reruns.

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

Trait Implementations

impl Clone for CompiledKernelRaw

fn clone(&self) -> CompiledKernelRaw

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Kernel for CompiledKernelRaw

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.