Struct XdnaProgram 

pub struct XdnaProgram(/* private fields */);

Loaded, bound XDNA entry with a private context and establishing command. Clones share one queue and up to 128 accepted invocations. Bindings remain leased until every outstanding invocation has retired.

Implementations

impl XdnaProgram

pub unsafe fn wrap_transaction( self, prefix: &[u8], prefix_operations: u32, suffix: &[u8], suffix_operations: u32, retained: &[Buffer], budget: Option<&MemoryBudget>, ) -> Result<Self>

Compose trusted native transaction records around the bound invocation. This consumes an exclusive, never-submitted program. The original command body is preserved; only its transaction size/count header is updated. Additional addressed buffers are retained through checked retirement.

Safety

Records must own disjoint native resources, preserve the establishing invocation, and drain every added DMA/worker before command completion. Every address they embed must belong to retained or existing bindings.

pub unsafe fn dispatch(&self) -> Result<XdnaCompletion>

Publish the complete establishing command and retain all external backing.

Safety

The caller orders conflicting accesses by other queues. The compiled program must obey each binding’s declared range and access contract.

Examples found in repository

examples/mall_probe.rs (line 55)

fn main() -> Result<()> {
    let seconds: f64 = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "2".into())
        .parse()
        .map_err(|e: std::num::ParseFloatError| hrx::Error::Message(e.to_string()))?;
    if !seconds.is_finite() || !(0.01..=3600.0).contains(&seconds) {
        return Err(hrx::Error::Message("seconds must be in 0.01..=3600".into()));
    }
    let device = Device::open(Engine::Xdna, 0)?;
    let compiler = Compiler::for_target(None, device.target())?;
    println!("working_set_MiB GB/s dispatches/s");
    for mib in [1, 4, 8, 16, 32, 64] {
        let bytes = mib * 1024 * 1024;
        let artifact = compiler
            .module(include_str!("../tests/kernels/copy.xdna.loom"))
            .compile(
                &Specialization::new("copy")
                    .with_config("copy.packets", (bytes / 4096).to_string()),
            )?;
        let input = device
            .fabric()
            .allocate(bytes, std::slice::from_ref(&device))?;
        let output = device
            .fabric()
            .allocate(bytes, std::slice::from_ref(&device))?;
        input.write(0, &vec![0x5a; bytes])?;
        let program = unsafe {
            device.prepare_xdna(
                &artifact,
                1,
                &[
                    XdnaBinding {
                        buffer: &input,
                        offset: 0,
                        length: bytes,
                    },
                    XdnaBinding {
                        buffer: &output,
                        offset: 0,
                        length: bytes,
                    },
                ],
            )
        }?;
        unsafe { program.dispatch() }?.wait()?;
        let mut check = vec![0; bytes];
        output.read(0, &mut check)?;
        assert!(check.iter().all(|&b| b == 0x5a));
        let start = Instant::now();
        let mut count = 0;
        while start.elapsed() < Duration::from_secs_f64(seconds) {
            unsafe { program.dispatch() }?.wait()?;
            count += 1;
        }
        let elapsed = start.elapsed().as_secs_f64();
        println!(
            "{} {:.3} {:.1}",
            2 * mib,
            2.0 * bytes as f64 * count as f64 / elapsed / 1e9,
            count as f64 / elapsed
        );
    }
    Ok(())
}

Trait Implementations

impl Clone for XdnaProgram

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.