Struct LaunchGeometry 

pub struct LaunchGeometry {
    pub cube_dim: CubeDim,
    pub cube_count: CubeCount,
}

Kernel launch geometry for the access patterns used by the DSP kernels.

Cube sizes come from the runtime (CubeDim::new: its plane size along x, a plane count set by the runtime’s cores or limits along y), never from constants, and cube counts from the problem size within the runtime’s grid limits. CubeCL maps cubes and units to whatever executes the kernel (CPU threads, GPU workgroups).

Fields

cube_dim: CubeDim

cube_count: CubeCount

Implementations

impl LaunchGeometry

pub fn elementwise(client: &Client, num_elements: usize) -> Self

One unit per element, indexed with element_position (contiguous runs per thread on the CPU runtime, ABSOLUTE_POS elsewhere). The cubes are spread over the runtime’s cube-count dimensions, so kernels must bound-check the position.

pub fn channels_samples( client: &Client, channels: usize, samples: usize, ) -> Self

One unit per (channel, sample) of a [channels, samples] buffer: sample_position and channel_position. The cube’s x size is the runtime’s plane, so a plane walks neighbouring samples of one channel.

Panics

If the channels or samples need more cubes than the runtime’s whole grid holds.

pub fn per_sample(client: &Client, samples: usize) -> Self

One unit per sample for kernels that walk all channels of a sample (sample_position).

pub fn per_channel(client: &Client, channels: usize) -> Self

One unit per channel for kernels that walk each channel sequentially in time: ABSOLUTE_POS_X = channel, bound-checked by the kernel.

pub fn per_row(client: &Client, rows: usize, cols: usize) -> Self

One cube per row of a [rows, cols] buffer, for cube-wide reductions: row_position is the row (cubes along x, continuing along y past the grid’s x limit) and UNIT_POS_X strides along it. The cube is the runtime’s cube for cols units flattened onto x and rounded down to a power of two, so tree reductions can halve it; kernels size shared memory with cube_dim.x (passed as a comptime value). Kernels bound-check the row.

Panics

If the rows need more cubes than the runtime’s whole grid holds.

pub fn tiles( client: &Client, points: usize, shared_bytes_per_unit: usize, ) -> Self

One unit per point of points, in 1-D cubes of a power-of-two number of units (the runtime’s cube flattened onto x, shrunk until shared_bytes_per_unit per unit fits the device’s shared memory) for kernels that share tiles of points in shared memory: the point is row_position() * CUBE_DIM_X + UNIT_POS_X, and kernels size shared memory with cube_dim.x (passed as a comptime value). Every unit of a cube takes part in the tile loads, so kernels bound-check the point only around their own work.

Panics

If one unit’s shared memory exceeds the device’s, or the points need more cubes than the runtime’s whole grid holds.

pub fn plane_lanes(client: &Client) -> u32

Units that execute in lock-step (the runtime’s plane / warp / subgroup size; 1 where every unit runs on its own, as on the CPU runtime). It is the x size of Self::channels_samples cubes, so consecutive sample_positions of a plane share a cube.

Trait Implementations

impl Clone for LaunchGeometry

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LaunchGeometry

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

Formats the value using the given formatter.