Struct SpirvModule 

pub struct SpirvModule { /* private fields */ }

Implementations

impl SpirvModule

pub fn words(&self) -> &[u32]

Examples found in repository

examples/pathfind.rs (line 8)

fn main() -> Result<()> {
    let source = fs::read_to_string("zusts/gpu/pathfind.zs")?;
    let kernel = compile_source_with_workgroup_size(&source, "pathfind", "main", [32, 32, 1])?;
    let words = kernel.spirv.words();
    let bytes: Vec<u8> = words.iter().flat_map(|w| w.to_le_bytes()).collect();
    fs::write("pathfind.spv", &bytes)?;
    println!("compiled pathfind.zs -> pathfind.spv ({} words, {} bytes)", words.len(), bytes.len());
    Ok(())
}

examples/poly.rs (line 6)

fn main() -> Result<()> {
    let source = std::fs::read("zusts/gpu/poly.zs")?;
    let kernel = vm_spirv::compile_source_with_workgroup_size(source, "poly", "main", [32, 32, 1])?;
    let bytes = kernel.spirv.words().iter().flat_map(|word| word.to_le_bytes()).collect::<Vec<_>>();
    std::fs::write("poly.spv", bytes)?;
    std::fs::write("poly.spvasm", kernel.spirv.disassemble())?;
    println!("wrote poly.spv ({} words)", kernel.spirv.words().len());
    Ok(())
}

examples/bitonic.rs (line 6)

fn main() -> Result<()> {
    let source = std::fs::read("zusts/gpu/bitonic.zs")?;
    let kernel = vm_spirv::compile_source_with_workgroup_size(source, "bitonic", "main", [256, 1, 1])?;
    let bytes = kernel.spirv.words().iter().flat_map(|word| word.to_le_bytes()).collect::<Vec<_>>();
    std::fs::write("bitonic.spv", bytes)?;
    std::fs::write("bitonic.spvasm", kernel.spirv.disassemble())?;
    println!("wrote bitonic.spv ({} words)", kernel.spirv.words().len());
    Ok(())
}

examples/mandelbrot.rs (line 14)

fn main() -> Result<()> {
    let source_path = std::env::var("MANDEL_ZS").unwrap_or_else(|_| "zusts/gpu/mandelbrot.zs".to_string());
    let module_name = std::env::var("MANDEL_MODULE").unwrap_or_else(|_| "mandelbrot".to_string());
    let spv_path = std::env::var("MANDEL_SPV").unwrap_or_else(|_| "mandel.spv".to_string());
    let asm_path = std::env::var("MANDEL_SPVASM").unwrap_or_else(|_| "mandel.spvasm".to_string());
    let local_size = std::env::var("MANDEL_LOCAL_SIZE").ok().map(|value| parse_workgroups(&value)).transpose()?.unwrap_or([16, 16, 1]);

    let kernel = vm_spirv::compile_file_with_generic_args_and_workgroup_size(&source_path, &module_name, "main", &[Type::ConstInt(BIGFLOAT_LIMBS as i64)], local_size)?;
    let bytes = kernel.spirv.words().iter().flat_map(|word| word.to_le_bytes()).collect::<Vec<_>>();
    std::fs::write(&spv_path, bytes)?;
    std::fs::write(&asm_path, kernel.spirv.disassemble())?;
    println!("compiled {source_path}");
    println!("bigfloat_limbs: {BIGFLOAT_LIMBS}");
    println!("wrote {spv_path} ({} words)", kernel.spirv.words().len());
    Ok(())
}

pub fn into_words(self) -> Vec<u32>

pub fn disassemble(&self) -> String

Examples found in repository

examples/poly.rs (line 8)

fn main() -> Result<()> {
    let source = std::fs::read("zusts/gpu/poly.zs")?;
    let kernel = vm_spirv::compile_source_with_workgroup_size(source, "poly", "main", [32, 32, 1])?;
    let bytes = kernel.spirv.words().iter().flat_map(|word| word.to_le_bytes()).collect::<Vec<_>>();
    std::fs::write("poly.spv", bytes)?;
    std::fs::write("poly.spvasm", kernel.spirv.disassemble())?;
    println!("wrote poly.spv ({} words)", kernel.spirv.words().len());
    Ok(())
}

examples/bitonic.rs (line 8)

fn main() -> Result<()> {
    let source = std::fs::read("zusts/gpu/bitonic.zs")?;
    let kernel = vm_spirv::compile_source_with_workgroup_size(source, "bitonic", "main", [256, 1, 1])?;
    let bytes = kernel.spirv.words().iter().flat_map(|word| word.to_le_bytes()).collect::<Vec<_>>();
    std::fs::write("bitonic.spv", bytes)?;
    std::fs::write("bitonic.spvasm", kernel.spirv.disassemble())?;
    println!("wrote bitonic.spv ({} words)", kernel.spirv.words().len());
    Ok(())
}

examples/mandelbrot.rs (line 16)

fn main() -> Result<()> {
    let source_path = std::env::var("MANDEL_ZS").unwrap_or_else(|_| "zusts/gpu/mandelbrot.zs".to_string());
    let module_name = std::env::var("MANDEL_MODULE").unwrap_or_else(|_| "mandelbrot".to_string());
    let spv_path = std::env::var("MANDEL_SPV").unwrap_or_else(|_| "mandel.spv".to_string());
    let asm_path = std::env::var("MANDEL_SPVASM").unwrap_or_else(|_| "mandel.spvasm".to_string());
    let local_size = std::env::var("MANDEL_LOCAL_SIZE").ok().map(|value| parse_workgroups(&value)).transpose()?.unwrap_or([16, 16, 1]);

    let kernel = vm_spirv::compile_file_with_generic_args_and_workgroup_size(&source_path, &module_name, "main", &[Type::ConstInt(BIGFLOAT_LIMBS as i64)], local_size)?;
    let bytes = kernel.spirv.words().iter().flat_map(|word| word.to_le_bytes()).collect::<Vec<_>>();
    std::fs::write(&spv_path, bytes)?;
    std::fs::write(&asm_path, kernel.spirv.disassemble())?;
    println!("compiled {source_path}");
    println!("bigfloat_limbs: {BIGFLOAT_LIMBS}");
    println!("wrote {spv_path} ({} words)", kernel.spirv.words().len());
    Ok(())
}

Trait Implementations

impl Clone for SpirvModule

fn clone(&self) -> SpirvModule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SpirvModule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.