Struct Conv2dBnSiluGemmForward 

pub struct Conv2dBnSiluGemmForward {
    pub name: &'static str,
    pub id: String,
    pub block_m: i32,
    pub block_n: i32,
    pub block_k: i32,
    pub group_m: i32,
    pub kernel_source: String,
    pub entry_point_source: String,
    pub source: String,
}

Fused Conv2d(1×1, stride=1, pad=0, groups=1) + BatchNorm2d + SiLU using GEMM.

A 1×1 stride=1 no-padding convolution is mathematically equivalent to: Y[N, M] = W[N, K] @ X[K, M] where: N = C_OUT, K = C_IN, M = OH * OW (batch handled in grid)

Input X is stored NCHW = [B, K, OH, OW], viewed as 2-D [K, OHOW] per batch (column-major spatial: stride_K = OHOW, stride_spatial = 1).

Weight W is [C_OUT, C_IN] row-major.

T::dot uses TF32 Tensor Cores on sm_87+ (Jetson Orin) for ~8× throughput vs direct scalar accumulation.

Restrictions (enforced by dispatch in graph/mod.rs):

• kernel_h == 1, kernel_w == 1
• stride_h == 1, stride_w == 1
• padding_h == 0, padding_w == 0
• groups == 1

BN parameters must be precomputed (same convention as conv2d_bn_silu_forward).

Grid: pid = b * num_pid_per_batch + group_id * (GROUP_M * num_pid_n) + pid_in_group (same L2-locality grouping as Triton’s matmul tutorial)

Inference-only; no backward pass.

Fields

name: &'static str

The kernel function’s name (e.g. "flash_attention2_forward").

id: String

Unique kernel identifier: fn_name + dtype(s) + const values joined by “__”.

block_m: i32

Compile-time kernel constant, from the annotated fn’s const generics.

block_n: i32

Compile-time kernel constant, from the annotated fn’s const generics.

block_k: i32

Compile-time kernel constant, from the annotated fn’s const generics.

group_m: i32

Compile-time kernel constant, from the annotated fn’s const generics.

kernel_source: String

The original kernel function source.

entry_point_source: String

The Rust source of the generated C-ABI entry-point wrapper function.

source: String

Combined source (kernel_source + "\n\n" + entry_point_source); used by the Kernel trait.

Implementations

impl Conv2dBnSiluGemmForward

pub fn new(block_m: i32, block_n: i32, block_k: i32, group_m: i32) -> Self

Constructs a new kernel instance for these compile-time parameters.

Trait Implementations

impl Kernel for Conv2dBnSiluGemmForward

type Args<'__a> = (*mut f32, *mut f32, *mut f32, *mut f32, *mut f32, i32, i32, i32, i32)

This kernel’s launch-argument tuple type.

fn id(&self) -> String

A content hash of this kernel’s source, used as a cache key.

fn name(&self) -> &str

This kernel’s name.

fn source(&self) -> &str

This kernel’s full source (DSL + kernel body + entry point wrapper).

fn kernel_source(&self) -> &str

This kernel’s body source, without the entry-point wrapper.

fn entry_point_source(&self) -> &str

Returns the Rust source of the generated C-ABI entry-point wrapper function.

fn entry_point_name(&self) -> String

Returns the PTX symbol name for this kernel: "{name}_entry_point".

impl RuntimeOp for Conv2dBnSiluGemmForward

fn n_activation_inputs(&self) -> usize

Number of activation tensors taken from predecessor DAG nodes.

fn param_shapes( &self, input_shapes: &[&[usize]], output_shape: &[usize], ) -> Vec<Vec<usize>>

Shapes of additional parameter buffers (weights, biases) needed by this op. Called at LoadedModel::load() time to pre-allocate device buffers. input_shapes / output_shape are concrete (batch dim resolved).

fn param_names(&self) -> &'static [&'static str]

Names of parameter slots returned by [param_shapes], in the same order. Used as the suffix in the dotted key {node_name}.{slot_name}. Return an empty slice for ops that have no named parameters.

fn pack_args( &self, inputs: &[(RawPtr, &[usize])], params: &[RawPtr], output: RawPtr, output_shape: &[usize], _output_row_stride: i32, visitor: &mut dyn ArgVisitor, )

Pack all kernel arguments into visitor in the correct order.

fn block(&self) -> [u32; 3]

Threads-per-CTA for this kernel (x, y, z).

fn grid(&self, output_shape: &[usize]) -> [u32; 3]

Number of CTAs to launch (x, y, z), given the concrete output shape.

fn forward_output_row_stride(&self, output_shape: &[usize]) -> usize

Returns the required row stride (in elements) for the output buffer of this op’s forward kernel. The default is the natural row-major stride (output_shape[-1]). Kernels using TMA must round up to satisfy the 16-byte alignment constraint (e.g. 4 elements for f32).

fn param_init_data(&self, _param_idx: usize) -> Option<Vec<u8>>

Returns raw (little-endian) bytes to pre-populate parameter slot param_idx immediately after device buffer allocation. Return None to leave the slot zero-initialised (the default for trained parameters). Byte count must equal param_shapes()[param_idx].iter().product() * dtype_bytes.

fn compute_concrete_output_shape( &self, _input_shapes: &[&[usize]], resolved: &[usize], ) -> Vec<usize>

Override to compute the true concrete output shape from concrete input shapes.

fn n_launches(&self) -> usize

Number of sequential kernel launches this op requires.

fn pack_args_for_launch( &self, launch_idx: usize, inputs: &[(*mut c_void, &[usize])], params: &[*mut c_void], output: *mut c_void, output_shape: &[usize], output_row_stride: i32, visitor: &mut dyn ArgVisitor, )

Pack kernel arguments for launch i (0-indexed).

fn grid_for_launch( &self, launch_idx: usize, input_shapes: &[&[usize]], output_shape: &[usize], ) -> [u32; 3]

Grid for launch i. Receives concrete input shapes so that per-chunk grids can be computed without storing them in the op.

fn has_backward(&self) -> bool

Returns true if this op has a backward (gradient) kernel.

fn backward_grad_output_row_stride(&self, output_shape: &[usize]) -> usize

Returns the required row stride (in elements) for the grad_output buffer passed to pack_backward_args. The default is the natural row-major stride (output_shape[-1]). Kernels using TMA must round up to satisfy the 16-byte alignment constraint (e.g. 4 elements for f32).

fn pack_backward_args( &self, inputs: &[(*mut c_void, &[usize])], params: &[*mut c_void], output: *mut c_void, output_shape: &[usize], grad_output: *mut c_void, grad_output_row_stride: i32, grad_inputs: &[*mut c_void], grad_params: &[*mut c_void], visitor: &mut dyn ArgVisitor, )

Pack backward kernel arguments.

fn backward_block(&self) -> [u32; 3]

Threads-per-CTA for the backward kernel.

fn backward_grid( &self, input_shapes: &[&[usize]], output_shape: &[usize], ) -> [u32; 3]

Number of CTAs for the backward kernel.

fn n_backward_launches(&self) -> usize

Number of sequential kernel launches for the backward pass.

fn pack_backward_args_for_launch( &self, launch_idx: usize, inputs: &[(*mut c_void, &[usize])], params: &[*mut c_void], output: *mut c_void, output_shape: &[usize], grad_output: *mut c_void, grad_output_row_stride: i32, grad_inputs: &[*mut c_void], grad_params: &[*mut c_void], visitor: &mut dyn ArgVisitor, )

Pack backward kernel arguments for launch i (0-indexed).

fn backward_grid_for_launch( &self, launch_idx: usize, input_shapes: &[&[usize]], output_shape: &[usize], ) -> [u32; 3]

Grid for backward launch i.