Struct Queue 

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

A serialized host producer for one native GPU PM4 queue.

Implementations

impl Queue

pub unsafe fn prepare( &self, kernel: &Kernel, grid: [u32; 3], block: [u16; 3], arguments: &[Argument<'_>], ) -> Result<PreparedGpu>

Prepare immutable commands and backing for repeated native execution.

Safety

Arguments and launch dimensions must satisfy the kernel’s memory contract. The caller orders conflicting accesses across other queues.

pub unsafe fn prepare_batch( &self, commands: &[(PreparedGpu, bool)], ) -> Result<PreparedGpu>

Combine prepared dispatches into one immutable indirect command buffer. A true flag establishes a system-memory dependency on preceding nodes.

Safety

The supplied barriers must order every conflicting access. Commands must obey their kernel contracts and must not use this batch’s storage elsewhere.

pub unsafe fn prepare_profiled_batch( &self, commands: &[(PreparedGpu, bool)], labels: &[String], ) -> Result<ProfiledGpu>

Instrument every prepared command, including nested batches as one span. Completion barriers serialize the sampled commands. This is diagnostic execution; use ordinary batches for end-to-end performance decisions.

Safety

The same kernel and cross-queue contracts as prepare_batch apply.

pub fn prepare_wait(&self, completion: &Completion) -> Result<PreparedGpu>

Prepare a device-side wait for an immutable completion point. The source fence and all indirect resources remain owned through retirement.

pub unsafe fn dispatch( &self, kernel: &Kernel, grid: [u32; 3], block: [u16; 3], arguments: &[Argument<'_>], ) -> Result<Completion>

Prepare and publish a single invocation.

Safety

The kernel and its arguments must obey the declared memory contract; callers order conflicting accesses on other queues.

impl Queue

pub fn family_ordinal(&self) -> u32

Exact native family used by this queue and its visibility recipes.

pub fn command(&self) -> QueueCommand

Native command representation.

pub fn device(&self) -> &Device

Device whose address domain this queue executes in.

pub fn prepare_copy( &self, destination: &Buffer, destination_offset: usize, source: &Buffer, source_offset: usize, length: usize, ) -> Result<PreparedGpu>

Prepare a copy of any nonempty, in-bounds, non-overlapping byte range. Large transfers are split to fit the selected engine. The returned completion covers every part; operands remain retained until retirement.

pub fn prepare_fill( &self, destination: &Buffer, offset: usize, length: usize, value: u8, ) -> Result<PreparedGpu>

Prepare a byte fill, splitting large ranges for the selected engine.

Examples found in repository

examples/unified_probe.rs (line 16)

fn main() -> Result<()> {
    let fabric = Fabric::resolve()?;
    let gpu = Device::open(Engine::Gpu, 0)?;
    let npu = Device::open(Engine::Xdna, 0)?;
    let buffer = fabric.allocate(1 << 20, &[gpu.clone(), npu.clone()])?;
    println!(
        "GPU address={:#x}, XDNA DMA address={:#x}",
        buffer.device_address(&gpu)?,
        buffer.device_address(&npu)?
    );
    let fill = gpu.queue()?.prepare_fill(&buffer, 0, buffer.len(), 0x5a)?;
    unsafe { fill.dispatch() }?.wait()?;
    let mut bytes = vec![0; buffer.len()];
    buffer.read(0, &mut bytes)?;
    assert!(bytes.iter().all(|&byte| byte == 0x5a));
    println!("native shared allocation: {} bytes verified", bytes.len());
    Ok(())
}

Trait Implementations

impl Clone for Queue

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.