Struct TensorExecutor 

pub struct TensorExecutor<'program> {
    pub packed_values: Vec<f32>,
    /* private fields */
}

Reusable buffers for running one program many times.

Fields

packed_values: Vec<f32>

After a run, packed_values[k] is the value of program.wire_order[k].

Implementations

impl<'program> TensorExecutor<'program>

pub fn new(program: &'program TensorProgram) -> TensorExecutor<'program>

Examples found in repository

examples/ui_panel.rs (line 142)

fn main() {
    let compiled = ui_frame_circuit();
    let report = compiled.verify(20_000).unwrap();
    eprintln!(
        "ui_frame: {} live operations in {} layers; verified on {} sampled inputs",
        compiled.program.live_operation_count(),
        compiled.program.layers.len(),
        report.checked
    );
    let _ = (TOGGLE, SLIDER_LEFT);
    let mut executor = TensorExecutor::new(&compiled.program);
    let mut source = Vec::new();
    let mut state = (false, false, false, 0u8, 0.0f32);
    println!("frame,x,y,held,pressed,released,on,armed,dragging,level,thumb");
    for (frame, (x, y, pressed, released, held)) in script().into_iter().enumerate() {
        let args = (state.0, state.1, state.2, state.3, state.4, x, y, pressed, released);
        source.clear();
        args.encode(&mut source);
        let outputs = executor.run(&source);
        let next = (outputs[0] == 1.0, outputs[1] == 1.0, outputs[2] == 1.0, outputs[3] as u8, outputs[4]);
        let expected = ui_frame(state.0, state.1, state.2, state.3, state.4, x, y, pressed, released);
        assert_eq!(next, expected, "frame {frame}: the circuit disagrees with ui_frame()");
        state = next;
        println!(
            "{frame},{x},{y},{},{},{},{},{},{},{},{}",
            held as u8, pressed as u8, released as u8, state.0 as u8, state.1 as u8, state.2 as u8, state.3, state.4
        );
    }
}

examples/life.rs (line 57)

fn main() {
    let compiled = life_step_circuit();
    let report = compiled.verify(200).unwrap();
    eprintln!(
        "life_step: {} live operations in {} layers; verified on {} random grids",
        compiled.program.live_operation_count(),
        compiled.program.layers.len(),
        report.checked
    );
    // Two gliders, a lightweight spaceship and an R-pentomino.
    let mut grid = [[false; N]; N];
    for (row, column) in [(1, 2), (2, 3), (3, 1), (3, 2), (3, 3)] {
        grid[row][column] = true;
    }
    for (row, column) in [(14, 4), (15, 5), (16, 3), (16, 4), (16, 5)] {
        grid[row][column] = true;
    }
    for (row, column) in [(4, 14), (4, 17), (5, 18), (6, 14), (6, 18), (7, 15), (7, 16), (7, 17), (7, 18)] {
        grid[row][column] = true;
    }
    for (row, column) in [(16, 16), (16, 17), (17, 15), (17, 16), (18, 16)] {
        grid[row][column] = true;
    }
    let mut executor = TensorExecutor::new(&compiled.program);
    let mut source = Vec::new();
    for generation in 0..120 {
        println!(
            "{}",
            grid.iter().flat_map(|row| row.iter().map(|&alive| if alive { '#' } else { '.' })).collect::<String>()
        );
        source.clear();
        (grid,).encode(&mut source);
        let outputs = executor.run(&source);
        let next: [[bool; N]; N] =
            std::array::from_fn(|row| std::array::from_fn(|column| outputs[row * N + column] == 1.0));
        assert_eq!(next, life_step(grid), "generation {generation}: the circuit disagrees with life_step()");
        grid = next;
    }
}

pub fn run(&mut self, source: &[f32]) -> &[f32]

Evaluate the program and return the roots’ values. The source is not range-checked; use Circuit::validate_source_ranges for that.

Examples found in repository

examples/ui_panel.rs (line 150)

fn main() {
    let compiled = ui_frame_circuit();
    let report = compiled.verify(20_000).unwrap();
    eprintln!(
        "ui_frame: {} live operations in {} layers; verified on {} sampled inputs",
        compiled.program.live_operation_count(),
        compiled.program.layers.len(),
        report.checked
    );
    let _ = (TOGGLE, SLIDER_LEFT);
    let mut executor = TensorExecutor::new(&compiled.program);
    let mut source = Vec::new();
    let mut state = (false, false, false, 0u8, 0.0f32);
    println!("frame,x,y,held,pressed,released,on,armed,dragging,level,thumb");
    for (frame, (x, y, pressed, released, held)) in script().into_iter().enumerate() {
        let args = (state.0, state.1, state.2, state.3, state.4, x, y, pressed, released);
        source.clear();
        args.encode(&mut source);
        let outputs = executor.run(&source);
        let next = (outputs[0] == 1.0, outputs[1] == 1.0, outputs[2] == 1.0, outputs[3] as u8, outputs[4]);
        let expected = ui_frame(state.0, state.1, state.2, state.3, state.4, x, y, pressed, released);
        assert_eq!(next, expected, "frame {frame}: the circuit disagrees with ui_frame()");
        state = next;
        println!(
            "{frame},{x},{y},{},{},{},{},{},{},{},{}",
            held as u8, pressed as u8, released as u8, state.0 as u8, state.1 as u8, state.2 as u8, state.3, state.4
        );
    }
}

examples/life.rs (line 66)

fn main() {
    let compiled = life_step_circuit();
    let report = compiled.verify(200).unwrap();
    eprintln!(
        "life_step: {} live operations in {} layers; verified on {} random grids",
        compiled.program.live_operation_count(),
        compiled.program.layers.len(),
        report.checked
    );
    // Two gliders, a lightweight spaceship and an R-pentomino.
    let mut grid = [[false; N]; N];
    for (row, column) in [(1, 2), (2, 3), (3, 1), (3, 2), (3, 3)] {
        grid[row][column] = true;
    }
    for (row, column) in [(14, 4), (15, 5), (16, 3), (16, 4), (16, 5)] {
        grid[row][column] = true;
    }
    for (row, column) in [(4, 14), (4, 17), (5, 18), (6, 14), (6, 18), (7, 15), (7, 16), (7, 17), (7, 18)] {
        grid[row][column] = true;
    }
    for (row, column) in [(16, 16), (16, 17), (17, 15), (17, 16), (18, 16)] {
        grid[row][column] = true;
    }
    let mut executor = TensorExecutor::new(&compiled.program);
    let mut source = Vec::new();
    for generation in 0..120 {
        println!(
            "{}",
            grid.iter().flat_map(|row| row.iter().map(|&alive| if alive { '#' } else { '.' })).collect::<String>()
        );
        source.clear();
        (grid,).encode(&mut source);
        let outputs = executor.run(&source);
        let next: [[bool; N]; N] =
            std::array::from_fn(|row| std::array::from_fn(|column| outputs[row * N + column] == 1.0));
        assert_eq!(next, life_step(grid), "generation {generation}: the circuit disagrees with life_step()");
        grid = next;
    }
}