Struct KernelArgs 

pub struct KernelArgs { /* private fields */ }

Typed builder for GPU kernel launch arguments.

KernelArgs packs scalar values and device-buffer pointers into the (args, arg_sizes) byte/size pair that the [fabricbios_gpu_v1] bridge expects. Each push_* records the raw bytes and their per-arg size so the daemon can build a CUDA kernelParams array with one pointer per argument.

Example

use grafos_std::gpu::{GpuBuilder, GpuSession, KernelArgs};

let lease = GpuBuilder::new().acquire()?;
let mut sess = GpuSession::new(&lease);
let buf = sess.mem_alloc(64)?;
let module = sess.module_load(&[0u8; 8])?;
let args = KernelArgs::new()
    .push_u32(7)
    .push_f32(2.5)
    .push_buffer(&buf);
sess.launch_with_args(&module, "k", [1, 1, 1], [1, 1, 1], args)?;

Wire format

• Scalars are written little-endian.
• Buffer args are written as 8-byte little-endian device pointers (the raw cuMemAlloc return value carried by GpuMemHandle).
• The daemon’s launch path packs these into a contiguous byte buffer and walks arg_sizes to compute per-arg pointer offsets for kernelParams. See crates/fabricbios-platform-linux/src/gpu.rs::launch.

Implementations

impl KernelArgs

pub fn new() -> Self

Create an empty argument list.

pub fn push_u32(self, v: u32) -> Self

Push a u32 argument.

pub fn push_u64(self, v: u64) -> Self

Push a u64 argument.

pub fn push_i32(self, v: i32) -> Self

Push an i32 argument.

pub fn push_i64(self, v: i64) -> Self

Push an i64 argument.

pub fn push_f32(self, v: f32) -> Self

Push an f32 argument.

pub fn push_f64(self, v: f64) -> Self

Push an f64 argument.

pub fn push_buffer(self, handle: &GpuMemHandle) -> Self

Push a device buffer argument (the raw 8-byte device pointer).

This is the typed equivalent of manually appending handle.raw().to_le_bytes() with size 8. The daemon will pass the underlying device pointer to the kernel as the corresponding kernelParams entry.

pub unsafe fn push_raw<T: Copy>(self, value: &T) -> Self

Push a value of arbitrary type by reinterpreting its bytes.

Safety

T must satisfy all of the following:

• Copy and trivially-destructible.
• No interior padding bytes whose value matters to the kernel. For C-ABI structs, this generally means #[repr(C)] plus manual layout review.
• No interior pointers, references, or non-'static lifetimes.
• Endianness matches what the kernel expects (host order is little-endian on every platform fabricBIOS targets).

In short: the value must be a “POD” (plain-old-data) blob that can be byte-copied into a CUDA kernelParams slot. Prefer the typed push_* helpers for primitive scalars; reach for push_raw only when packing a #[repr(C)] struct argument.

pub fn build(self) -> (Vec<u8>, Vec<u32>)

Consume the builder and return the raw (bytes, sizes) pair suitable for GpuSession::launch.

Trait Implementations

impl Clone for KernelArgs

fn clone(&self) -> KernelArgs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KernelArgs

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

Formats the value using the given formatter.

impl Default for KernelArgs

fn default() -> KernelArgs

Returns the “default value” for a type.