Struct GpuProgram 

pub struct GpuProgram {
    pub source_size: usize,
    pub output_count: usize,
    pub operation_count: usize,
    pub carried: usize,
    pub stages: Vec<String>,
    pub dispatch_records: Option<usize>,
    /* private fields */
}

A compiled program on the GPU: a pipeline per shader stage and the constant tables.

Fields

source_size: usize

output_count: usize

operation_count: usize

Operations the shaders evaluate per record.

carried: usize

32-bit words per record that stages pass to later stages.

stages: Vec<String>

The WGSL of each stage, run in order.

dispatch_records: Option<usize>

At most this many records per dispatch; None fits each dispatch’s buffers in the device’s storage binding limit.

Implementations

impl GpuProgram

pub fn new( gpu: &Gpu, circuit: &Circuit, roots: &[Wire], ) -> Result<GpuProgram, GpuError>

Compile the operations that roots need into shaders.

pub fn from_program( gpu: &Gpu, program: &TensorProgram, ) -> Result<GpuProgram, GpuError>

pub fn from_program_staged( gpu: &Gpu, program: &TensorProgram, statements: usize, ) -> Result<GpuProgram, GpuError>

Like GpuProgram::from_program, starting a new stage after statements statements whatever the program’s length (usize::MAX for one shader).

pub fn run(&self, gpu: &Gpu, sources: &[f32]) -> Result<Vec<f32>, GpuError>

Evaluate a batch: sources holds one source table after another, and the result holds each record’s outputs in the order of the roots.