Struct LaunchOptions 

pub struct LaunchOptions {
    pub mode: KernelMode,
    pub grid_size: u32,
    pub block_size: u32,
    pub input_queue_capacity: usize,
    pub output_queue_capacity: usize,
    pub shared_memory_size: usize,
    pub auto_activate: bool,
    pub cooperative: bool,
    pub enable_k2k: bool,
    pub scheduler_config: Option<SchedulerConfig>,
}

Options for launching a kernel.

Fields

mode: KernelMode

Execution mode (persistent or event-driven).

grid_size: u32

Grid size (number of blocks).

block_size: u32

Block size (threads per block).

input_queue_capacity: usize

Input queue capacity.

output_queue_capacity: usize

Output queue capacity.

shared_memory_size: usize

Shared memory size in bytes.

auto_activate: bool

Whether to activate immediately after launch.

cooperative: bool

Enable cooperative groups for grid-wide synchronization. Requires GPU support for cooperative kernel launch.

enable_k2k: bool

Enable K2K (kernel-to-kernel) messaging. Allocates routing table and inbox buffers on GPU.

scheduler_config: Option<SchedulerConfig>

Dynamic scheduling configuration for persistent actor load balancing.

When set to a non-Static strategy, the codegen layer generates a scheduler warp pattern: warp 0 in each block handles work distribution, remaining warps perform computation.

Default: None (static scheduling, current behavior).

Implementations

impl LaunchOptions

pub fn single_block(block_size: u32) -> Self

Create options for a single-block kernel.

pub fn multi_block(grid_size: u32, block_size: u32) -> Self

Create options for a multi-block kernel.

pub fn with_mode(self, mode: KernelMode) -> Self

Set execution mode.

pub fn with_queue_capacity(self, capacity: usize) -> Self

Set queue capacities.

pub fn with_shared_memory(self, size: usize) -> Self

Set shared memory size.

pub fn without_auto_activate(self) -> Self

Disable auto-activation.

pub fn with_grid_size(self, grid_size: u32) -> Self

Set the grid size (number of blocks).

pub fn with_block_size(self, block_size: u32) -> Self

Set the block size (threads per block).

pub fn with_cooperative(self, cooperative: bool) -> Self

Enable cooperative groups for grid-wide synchronization.

When enabled, the kernel will be launched cooperatively, allowing all blocks to synchronize via grid.sync(). Requires GPU support and nvcc at build time.

pub fn with_k2k(self, enable: bool) -> Self

Enable K2K (kernel-to-kernel) messaging.

When enabled, allocates routing table and inbox buffers on GPU for direct kernel-to-kernel communication without host intervention.

pub fn with_scheduler(self, config: SchedulerConfig) -> Self

Configure dynamic actor scheduling for load balancing.

When set, the codegen layer generates a scheduler warp pattern within each persistent kernel block. Warp 0 handles work distribution (stealing, round-robin, or priority-based), while remaining warps process messages.

Example

use ringkernel_core::scheduling::SchedulerConfig;

let options = LaunchOptions::default()
    .with_scheduler(SchedulerConfig::work_stealing(8)
        .with_max_steal_batch(16));

pub fn with_priority(self, _priority: u8) -> Self

Set priority hint for kernel scheduling.

Note: This is a hint for future use - currently ignored by backends.

pub fn with_input_queue_capacity(self, capacity: usize) -> Self

Set input queue capacity only.

pub fn with_output_queue_capacity(self, capacity: usize) -> Self

Set output queue capacity only.

Trait Implementations

impl Clone for LaunchOptions

fn clone(&self) -> LaunchOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LaunchOptions

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

Formats the value using the given formatter.

impl Default for LaunchOptions

fn default() -> Self

Returns the “default value” for a type.