Publish PyC CUDA kernel lab and performance summary

19 documented kernel-lab entries, prototype sources, manifests, and a concise H100 performance summary.

PERFORMANCE_SUMMARY.md

@@ -0,0 +1,17 @@
+# Performance summary
+
+These figures are selected from the PyC H100 kernel-lab campaign and are
+included as orientation, not as universal benchmark claims.
+
+| Lane | Shape | Result |
+| --- | --- | --- |
+| Hopper WMMA FP16 | 1024^3 | 0.105 ms, 20.473 TFLOPS |
+| Hopper WMMA BF16 | 1024^3 | 0.102 ms, 21.024 TFLOPS |
+| Hopper cuBLASLt BF16 control | 4096^3 | 0.162 ms, 846.466 TFLOPS |
+| Hopper async square K64 | 4096^3 | 0.9252 ms in the captured profile |
+
+The engineering progression is: shared-memory tiling and reuse, WMMA Tensor
+Core execution, BF16/FP16 comparison, `cp.async` double buffering, CTA shape
+and warp-work assignment, K-stage depth, and finally a cuBLASLt control lane.
+Always interpret a result together with GPU model, architecture, CUDA version,
+matrix shape, warmup/repeat policy, and correctness mode.

README.md

@@ -0,0 +1,38 @@
+---
+license: apache-2.0
+tags:
+- cuda
+- gpu-optimization
+- kernels
+- gemm
+- hpc
+---
+
+# PyC CUDA kernel lab
+
+This repository documents 19 CUDA kernel-lab entries from PyC. It is a source
+and evidence release, not a compiled binary distribution and not a claim that
+all entries are wired into PyC runtime dispatch.
+
+## Contents
+
+- `kernels/prototypes/`: standalone CUDA prototype sources.
+- `manifests/kernels.json`: the 19-entry lab catalog, including build/run commands.
+- `manifests/kernels.json`: the catalog mirrored into the registry release.
+- `PERFORMANCE_SUMMARY.md`: selected H100 campaign measurements and the optimization progression.
+
+## Optimization themes
+
+The progression covers shared-memory tiling, WMMA Tensor Core execution, BF16
+versus FP16, `cp.async` double buffering, CTA shape, K-stage depth, warp work
+assignment, and cuBLASLt as a hardware-library ceiling/control.
+
+Performance numbers are campaign-specific measurements. They should be read
+with the GPU, CUDA toolchain, matrix shape, correctness mode, and timing method
+from the accompanying evidence; they are not universal benchmarks.
+
+## Reproduce
+
+The commands in `manifests/kernels.json` use `{nvcc}`, `{source}`, and
+`{build_dir}` placeholders. Replace them with a CUDA 12.x toolchain, a suitable
+Hopper or Ada GPU, and a local build directory before running.

kernels/prototypes/ada/gemm/kernel.cu

@@ -0,0 +1,336 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_BLOCK_M 64
+#define PYC_ADA_BLOCK_N 64
+#define PYC_ADA_BLOCK_K 16
+#define PYC_ADA_THREADS_X 16
+#define PYC_ADA_THREADS_Y 16
+#define PYC_ADA_THREAD_TILE_M 4
+#define PYC_ADA_THREAD_TILE_N 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(
+    const float* a,
+    const float* b,
+    float* c,
+    int m,
+    int n,
+    int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_THREADS_X * PYC_ADA_THREADS_Y, 2)
+__global__ void ada_fp32_tiled_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float a_tile[PYC_ADA_BLOCK_M][PYC_ADA_BLOCK_K];
+    __shared__ float b_tile[PYC_ADA_BLOCK_K][PYC_ADA_BLOCK_N];
+
+    const int thread_row = threadIdx.y;
+    const int thread_col = threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_BLOCK_N;
+    const int lane_linear = thread_row * blockDim.x + thread_col;
+    const int a_loads_per_thread = (PYC_ADA_BLOCK_M * PYC_ADA_BLOCK_K) / (PYC_ADA_THREADS_X * PYC_ADA_THREADS_Y);
+    const int b_loads_per_thread = (PYC_ADA_BLOCK_K * PYC_ADA_BLOCK_N) / (PYC_ADA_THREADS_X * PYC_ADA_THREADS_Y);
+    float accum[PYC_ADA_THREAD_TILE_M][PYC_ADA_THREAD_TILE_N];
+    int row_fragment = thread_row * PYC_ADA_THREAD_TILE_M;
+    int col_fragment = thread_col * PYC_ADA_THREAD_TILE_N;
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_BLOCK_K) {
+        for (i = 0; i < a_loads_per_thread; ++i) {
+            int linear = lane_linear * a_loads_per_thread + i;
+            int tile_row = linear / PYC_ADA_BLOCK_K;
+            int tile_col = linear % PYC_ADA_BLOCK_K;
+            int global_row = block_row + tile_row;
+            int global_col = kk_base + tile_col;
+            float value = 0.0f;
+            if (global_row < m && global_col < k) {
+                value = a[global_row * k + global_col];
+            }
+            a_tile[tile_row][tile_col] = value;
+        }
+
+        for (i = 0; i < b_loads_per_thread; ++i) {
+            int linear = lane_linear * b_loads_per_thread + i;
+            int tile_row = linear / PYC_ADA_BLOCK_N;
+            int tile_col = linear % PYC_ADA_BLOCK_N;
+            int global_row = kk_base + tile_row;
+            int global_col = block_col + tile_col;
+            float value = 0.0f;
+            if (global_row < k && global_col < n) {
+                value = b[global_row * n + global_col];
+            }
+            b_tile[tile_row][tile_col] = value;
+        }
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_THREAD_TILE_M];
+            float b_frag[PYC_ADA_THREAD_TILE_N];
+
+            #pragma unroll
+            for (j = 0; j < PYC_ADA_THREAD_TILE_M; ++j) {
+                a_frag[j] = a_tile[row_fragment + j][i];
+            }
+            #pragma unroll
+            for (j = 0; j < PYC_ADA_THREAD_TILE_N; ++j) {
+                b_frag[j] = b_tile[i][col_fragment + j];
+            }
+            #pragma unroll
+            for (j = 0; j < PYC_ADA_THREAD_TILE_M; ++j) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_THREAD_TILE_N; ++jj) {
+                    accum[j][jj] += a_frag[j] * b_frag[jj];
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        for (j = 0; j < PYC_ADA_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_tiled_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_THREADS_X, PYC_ADA_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_BLOCK_N - 1) / PYC_ADA_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_BLOCK_M - 1) / PYC_ADA_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_tiled_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_tiled_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d\n",
+           PYC_ADA_BLOCK_M,
+           PYC_ADA_BLOCK_N,
+           PYC_ADA_BLOCK_K,
+           PYC_ADA_THREADS_X,
+           PYC_ADA_THREADS_Y);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k128_warp32/kernel.cu

@@ -0,0 +1,388 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_K128WARP_BLOCK_M 64
+#define PYC_ADA_K128WARP_BLOCK_N 64
+#define PYC_ADA_K128WARP_BLOCK_K 128
+#define PYC_ADA_K128WARP_THREADS_X 32
+#define PYC_ADA_K128WARP_THREADS_Y 8
+#define PYC_ADA_K128WARP_THREAD_TILE_M 8
+#define PYC_ADA_K128WARP_THREAD_TILE_N 2
+#define PYC_ADA_K128WARP_VEC 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k128warp_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float shared_a[PYC_ADA_K128WARP_BLOCK_M][PYC_ADA_K128WARP_BLOCK_K + 1],
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_K128WARP_BLOCK_K / PYC_ADA_K128WARP_VEC;
+    const int total_vecs = (PYC_ADA_K128WARP_BLOCK_M * PYC_ADA_K128WARP_BLOCK_K) / PYC_ADA_K128WARP_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K128WARP_THREADS_X * PYC_ADA_K128WARP_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K128WARP_THREADS_X * PYC_ADA_K128WARP_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K128WARP_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (global_row < m && global_col + (PYC_ADA_K128WARP_VEC - 1) < k) {
+            const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+            shared_a[tile_row][tile_col + 0] = value.x;
+            shared_a[tile_row][tile_col + 1] = value.y;
+            shared_a[tile_row][tile_col + 2] = value.z;
+            shared_a[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K128WARP_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float shared_b[PYC_ADA_K128WARP_BLOCK_K][PYC_ADA_K128WARP_BLOCK_N + 1],
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_K128WARP_BLOCK_N / PYC_ADA_K128WARP_VEC;
+    const int total_vecs = (PYC_ADA_K128WARP_BLOCK_K * PYC_ADA_K128WARP_BLOCK_N) / PYC_ADA_K128WARP_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K128WARP_THREADS_X * PYC_ADA_K128WARP_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K128WARP_THREADS_X * PYC_ADA_K128WARP_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K128WARP_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (global_row < k && global_col + (PYC_ADA_K128WARP_VEC - 1) < n) {
+            const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+            shared_b[tile_row][tile_col + 0] = value.x;
+            shared_b[tile_row][tile_col + 1] = value.y;
+            shared_b[tile_row][tile_col + 2] = value.z;
+            shared_b[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K128WARP_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K128WARP_THREADS_X * PYC_ADA_K128WARP_THREADS_Y, 1)
+__global__ void ada_fp32_k128warp_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float shared_a[PYC_ADA_K128WARP_BLOCK_M][PYC_ADA_K128WARP_BLOCK_K + 1];
+    __shared__ float shared_b[PYC_ADA_K128WARP_BLOCK_K][PYC_ADA_K128WARP_BLOCK_N + 1];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K128WARP_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K128WARP_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K128WARP_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K128WARP_THREAD_TILE_N;
+    float accum[PYC_ADA_K128WARP_THREAD_TILE_M][PYC_ADA_K128WARP_THREAD_TILE_N];
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_K128WARP_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_K128WARP_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K128WARP_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K128WARP_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_K128WARP_THREAD_TILE_M];
+            float b_frag[PYC_ADA_K128WARP_THREAD_TILE_N];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K128WARP_THREAD_TILE_M; ++ii) {
+                a_frag[ii] = shared_a[row_fragment + ii][i];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K128WARP_THREAD_TILE_N; ++ii) {
+                b_frag[ii] = shared_b[i][col_fragment + ii];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K128WARP_THREAD_TILE_M; ++ii) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_K128WARP_THREAD_TILE_N; ++jj) {
+                    accum[ii][jj] += a_frag[ii] * b_frag[jj];
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_K128WARP_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        for (j = 0; j < PYC_ADA_K128WARP_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k128warp_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k128warp_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k128warp_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K128WARP_THREADS_X, PYC_ADA_K128WARP_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K128WARP_BLOCK_N - 1) / PYC_ADA_K128WARP_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K128WARP_BLOCK_M - 1) / PYC_ADA_K128WARP_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k128warp_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k128warp_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K128WARP_BLOCK_M,
+           PYC_ADA_K128WARP_BLOCK_N,
+           PYC_ADA_K128WARP_BLOCK_K,
+           PYC_ADA_K128WARP_THREADS_X,
+           PYC_ADA_K128WARP_THREADS_Y,
+           PYC_ADA_K128WARP_THREAD_TILE_M,
+           PYC_ADA_K128WARP_THREAD_TILE_N,
+           PYC_ADA_K128WARP_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k128_warp32_dyn/kernel.cu

@@ -0,0 +1,428 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_K128D_BLOCK_M 64
+#define PYC_ADA_K128D_BLOCK_N 64
+#define PYC_ADA_K128D_BLOCK_K 128
+#define PYC_ADA_K128D_THREADS_X 32
+#define PYC_ADA_K128D_THREADS_Y 8
+#define PYC_ADA_K128D_THREAD_TILE_M 8
+#define PYC_ADA_K128D_THREAD_TILE_N 2
+#define PYC_ADA_K128D_VEC 4
+#define PYC_ADA_K128D_SHARED_A_STRIDE (PYC_ADA_K128D_BLOCK_K + 1)
+#define PYC_ADA_K128D_SHARED_B_STRIDE (PYC_ADA_K128D_BLOCK_N + 1)
+#define PYC_ADA_K128D_SHARED_A_ELEMS (PYC_ADA_K128D_BLOCK_M * PYC_ADA_K128D_SHARED_A_STRIDE)
+#define PYC_ADA_K128D_SHARED_B_ELEMS (PYC_ADA_K128D_BLOCK_K * PYC_ADA_K128D_SHARED_B_STRIDE)
+#define PYC_ADA_K128D_SHARED_BYTES ((PYC_ADA_K128D_SHARED_A_ELEMS + PYC_ADA_K128D_SHARED_B_ELEMS) * (int)sizeof(float))
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k128d_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ __forceinline__ float* shared_a_ptr(float* shared_mem) {
+    return shared_mem;
+}
+
+__device__ __forceinline__ float* shared_b_ptr(float* shared_mem) {
+    return shared_mem + PYC_ADA_K128D_SHARED_A_ELEMS;
+}
+
+__device__ __forceinline__ float shared_a_load(const float* shared_a, int row, int col) {
+    return shared_a[row * PYC_ADA_K128D_SHARED_A_STRIDE + col];
+}
+
+__device__ __forceinline__ float shared_b_load(const float* shared_b, int row, int col) {
+    return shared_b[row * PYC_ADA_K128D_SHARED_B_STRIDE + col];
+}
+
+__device__ __forceinline__ void shared_a_store(float* shared_a, int row, int col, float value) {
+    shared_a[row * PYC_ADA_K128D_SHARED_A_STRIDE + col] = value;
+}
+
+__device__ __forceinline__ void shared_b_store(float* shared_b, int row, int col, float value) {
+    shared_b[row * PYC_ADA_K128D_SHARED_B_STRIDE + col] = value;
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float* shared_a,
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_K128D_BLOCK_K / PYC_ADA_K128D_VEC;
+    const int total_vecs = (PYC_ADA_K128D_BLOCK_M * PYC_ADA_K128D_BLOCK_K) / PYC_ADA_K128D_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K128D_THREADS_X * PYC_ADA_K128D_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K128D_THREADS_X * PYC_ADA_K128D_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K128D_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (global_row < m && global_col + (PYC_ADA_K128D_VEC - 1) < k) {
+            const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+            shared_a_store(shared_a, tile_row, tile_col + 0, value.x);
+            shared_a_store(shared_a, tile_row, tile_col + 1, value.y);
+            shared_a_store(shared_a, tile_row, tile_col + 2, value.z);
+            shared_a_store(shared_a, tile_row, tile_col + 3, value.w);
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K128D_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a_store(shared_a, tile_row, tile_col + i, value);
+        }
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float* shared_b,
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_K128D_BLOCK_N / PYC_ADA_K128D_VEC;
+    const int total_vecs = (PYC_ADA_K128D_BLOCK_K * PYC_ADA_K128D_BLOCK_N) / PYC_ADA_K128D_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K128D_THREADS_X * PYC_ADA_K128D_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K128D_THREADS_X * PYC_ADA_K128D_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K128D_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (global_row < k && global_col + (PYC_ADA_K128D_VEC - 1) < n) {
+            const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+            shared_b_store(shared_b, tile_row, tile_col + 0, value.x);
+            shared_b_store(shared_b, tile_row, tile_col + 1, value.y);
+            shared_b_store(shared_b, tile_row, tile_col + 2, value.z);
+            shared_b_store(shared_b, tile_row, tile_col + 3, value.w);
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K128D_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b_store(shared_b, tile_row, tile_col + i, value);
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K128D_THREADS_X * PYC_ADA_K128D_THREADS_Y, 1)
+__global__ void ada_fp32_k128dyn_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    extern __shared__ float shared_mem[];
+    float* shared_a = shared_a_ptr(shared_mem);
+    float* shared_b = shared_b_ptr(shared_mem);
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K128D_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K128D_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K128D_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K128D_THREAD_TILE_N;
+    float accum[PYC_ADA_K128D_THREAD_TILE_M][PYC_ADA_K128D_THREAD_TILE_N];
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_K128D_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_K128D_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K128D_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K128D_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_K128D_THREAD_TILE_M];
+            float b_frag[PYC_ADA_K128D_THREAD_TILE_N];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K128D_THREAD_TILE_M; ++ii) {
+                a_frag[ii] = shared_a_load(shared_a, row_fragment + ii, i);
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K128D_THREAD_TILE_N; ++ii) {
+                b_frag[ii] = shared_b_load(shared_b, i, col_fragment + ii);
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K128D_THREAD_TILE_M; ++ii) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_K128D_THREAD_TILE_N; ++jj) {
+                    accum[ii][jj] += a_frag[ii] * b_frag[jj];
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_K128D_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        for (j = 0; j < PYC_ADA_K128D_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k128dyn_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute carveout failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k128dyn_gemm,
+        cudaFuncAttributeMaxDynamicSharedMemorySize,
+        PYC_ADA_K128D_SHARED_BYTES);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute dynamic shared failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k128d_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k128d_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    printf("dynamic_shared_bytes=%d\n", PYC_ADA_K128D_SHARED_BYTES);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K128D_THREADS_X, PYC_ADA_K128D_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K128D_BLOCK_N - 1) / PYC_ADA_K128D_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K128D_BLOCK_M - 1) / PYC_ADA_K128D_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k128dyn_gemm<<<grid, block, PYC_ADA_K128D_SHARED_BYTES>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k128dyn_gemm<<<grid, block, PYC_ADA_K128D_SHARED_BYTES>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K128D_BLOCK_M,
+           PYC_ADA_K128D_BLOCK_N,
+           PYC_ADA_K128D_BLOCK_K,
+           PYC_ADA_K128D_THREADS_X,
+           PYC_ADA_K128D_THREADS_Y,
+           PYC_ADA_K128D_THREAD_TILE_M,
+           PYC_ADA_K128D_THREAD_TILE_N,
+           PYC_ADA_K128D_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k32/kernel.cu

@@ -0,0 +1,394 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_K32_BLOCK_M 64
+#define PYC_ADA_K32_BLOCK_N 64
+#define PYC_ADA_K32_BLOCK_K 32
+#define PYC_ADA_K32_THREADS_X 16
+#define PYC_ADA_K32_THREADS_Y 16
+#define PYC_ADA_K32_THREAD_TILE_M 4
+#define PYC_ADA_K32_THREAD_TILE_N 4
+#define PYC_ADA_K32_VEC 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k32_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(
+    const float* a,
+    const float* b,
+    float* c,
+    int m,
+    int n,
+    int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float shared_a[PYC_ADA_K32_BLOCK_M][PYC_ADA_K32_BLOCK_K + 1],
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_K32_BLOCK_K / PYC_ADA_K32_VEC;
+    const int total_vecs = (PYC_ADA_K32_BLOCK_M * PYC_ADA_K32_BLOCK_K) / PYC_ADA_K32_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K32_THREADS_X * PYC_ADA_K32_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K32_THREADS_X * PYC_ADA_K32_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K32_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (global_row < m && global_col + (PYC_ADA_K32_VEC - 1) < k) {
+            const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+            shared_a[tile_row][tile_col + 0] = value.x;
+            shared_a[tile_row][tile_col + 1] = value.y;
+            shared_a[tile_row][tile_col + 2] = value.z;
+            shared_a[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K32_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float shared_b[PYC_ADA_K32_BLOCK_K][PYC_ADA_K32_BLOCK_N + 1],
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_K32_BLOCK_N / PYC_ADA_K32_VEC;
+    const int total_vecs = (PYC_ADA_K32_BLOCK_K * PYC_ADA_K32_BLOCK_N) / PYC_ADA_K32_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K32_THREADS_X * PYC_ADA_K32_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K32_THREADS_X * PYC_ADA_K32_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K32_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (global_row < k && global_col + (PYC_ADA_K32_VEC - 1) < n) {
+            const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+            shared_b[tile_row][tile_col + 0] = value.x;
+            shared_b[tile_row][tile_col + 1] = value.y;
+            shared_b[tile_row][tile_col + 2] = value.z;
+            shared_b[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K32_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K32_THREADS_X * PYC_ADA_K32_THREADS_Y, 2)
+__global__ void ada_fp32_k32_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float shared_a[PYC_ADA_K32_BLOCK_M][PYC_ADA_K32_BLOCK_K + 1];
+    __shared__ float shared_b[PYC_ADA_K32_BLOCK_K][PYC_ADA_K32_BLOCK_N + 1];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K32_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K32_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K32_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K32_THREAD_TILE_N;
+    float accum[PYC_ADA_K32_THREAD_TILE_M][PYC_ADA_K32_THREAD_TILE_N];
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_K32_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_K32_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K32_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K32_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_K32_THREAD_TILE_M];
+            float b_frag[PYC_ADA_K32_THREAD_TILE_N];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K32_THREAD_TILE_M; ++ii) {
+                a_frag[ii] = shared_a[row_fragment + ii][i];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K32_THREAD_TILE_N; ++ii) {
+                b_frag[ii] = shared_b[i][col_fragment + ii];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K32_THREAD_TILE_M; ++ii) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_K32_THREAD_TILE_N; ++jj) {
+                    accum[ii][jj] += a_frag[ii] * b_frag[jj];
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_K32_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        for (j = 0; j < PYC_ADA_K32_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k32_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k32_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k32_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K32_THREADS_X, PYC_ADA_K32_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K32_BLOCK_N - 1) / PYC_ADA_K32_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K32_BLOCK_M - 1) / PYC_ADA_K32_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k32_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k32_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K32_BLOCK_M,
+           PYC_ADA_K32_BLOCK_N,
+           PYC_ADA_K32_BLOCK_K,
+           PYC_ADA_K32_THREADS_X,
+           PYC_ADA_K32_THREADS_Y,
+           PYC_ADA_K32_THREAD_TILE_M,
+           PYC_ADA_K32_THREAD_TILE_N,
+           PYC_ADA_K32_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k32_warp32/kernel.cu

@@ -0,0 +1,388 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_K32WARP_BLOCK_M 64
+#define PYC_ADA_K32WARP_BLOCK_N 64
+#define PYC_ADA_K32WARP_BLOCK_K 32
+#define PYC_ADA_K32WARP_THREADS_X 32
+#define PYC_ADA_K32WARP_THREADS_Y 8
+#define PYC_ADA_K32WARP_THREAD_TILE_M 8
+#define PYC_ADA_K32WARP_THREAD_TILE_N 2
+#define PYC_ADA_K32WARP_VEC 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k32warp_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float shared_a[PYC_ADA_K32WARP_BLOCK_M][PYC_ADA_K32WARP_BLOCK_K + 1],
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_K32WARP_BLOCK_K / PYC_ADA_K32WARP_VEC;
+    const int total_vecs = (PYC_ADA_K32WARP_BLOCK_M * PYC_ADA_K32WARP_BLOCK_K) / PYC_ADA_K32WARP_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K32WARP_THREADS_X * PYC_ADA_K32WARP_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K32WARP_THREADS_X * PYC_ADA_K32WARP_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K32WARP_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (global_row < m && global_col + (PYC_ADA_K32WARP_VEC - 1) < k) {
+            const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+            shared_a[tile_row][tile_col + 0] = value.x;
+            shared_a[tile_row][tile_col + 1] = value.y;
+            shared_a[tile_row][tile_col + 2] = value.z;
+            shared_a[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K32WARP_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float shared_b[PYC_ADA_K32WARP_BLOCK_K][PYC_ADA_K32WARP_BLOCK_N + 1],
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_K32WARP_BLOCK_N / PYC_ADA_K32WARP_VEC;
+    const int total_vecs = (PYC_ADA_K32WARP_BLOCK_K * PYC_ADA_K32WARP_BLOCK_N) / PYC_ADA_K32WARP_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K32WARP_THREADS_X * PYC_ADA_K32WARP_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K32WARP_THREADS_X * PYC_ADA_K32WARP_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K32WARP_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (global_row < k && global_col + (PYC_ADA_K32WARP_VEC - 1) < n) {
+            const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+            shared_b[tile_row][tile_col + 0] = value.x;
+            shared_b[tile_row][tile_col + 1] = value.y;
+            shared_b[tile_row][tile_col + 2] = value.z;
+            shared_b[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K32WARP_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K32WARP_THREADS_X * PYC_ADA_K32WARP_THREADS_Y, 2)
+__global__ void ada_fp32_k32warp_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float shared_a[PYC_ADA_K32WARP_BLOCK_M][PYC_ADA_K32WARP_BLOCK_K + 1];
+    __shared__ float shared_b[PYC_ADA_K32WARP_BLOCK_K][PYC_ADA_K32WARP_BLOCK_N + 1];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K32WARP_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K32WARP_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K32WARP_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K32WARP_THREAD_TILE_N;
+    float accum[PYC_ADA_K32WARP_THREAD_TILE_M][PYC_ADA_K32WARP_THREAD_TILE_N];
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_K32WARP_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_K32WARP_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K32WARP_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K32WARP_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_K32WARP_THREAD_TILE_M];
+            float b_frag[PYC_ADA_K32WARP_THREAD_TILE_N];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K32WARP_THREAD_TILE_M; ++ii) {
+                a_frag[ii] = shared_a[row_fragment + ii][i];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K32WARP_THREAD_TILE_N; ++ii) {
+                b_frag[ii] = shared_b[i][col_fragment + ii];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K32WARP_THREAD_TILE_M; ++ii) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_K32WARP_THREAD_TILE_N; ++jj) {
+                    accum[ii][jj] += a_frag[ii] * b_frag[jj];
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_K32WARP_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        for (j = 0; j < PYC_ADA_K32WARP_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k32warp_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k32warp_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k32warp_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K32WARP_THREADS_X, PYC_ADA_K32WARP_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K32WARP_BLOCK_N - 1) / PYC_ADA_K32WARP_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K32WARP_BLOCK_M - 1) / PYC_ADA_K32WARP_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k32warp_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k32warp_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K32WARP_BLOCK_M,
+           PYC_ADA_K32WARP_BLOCK_N,
+           PYC_ADA_K32WARP_BLOCK_K,
+           PYC_ADA_K32WARP_THREADS_X,
+           PYC_ADA_K32WARP_THREADS_Y,
+           PYC_ADA_K32WARP_THREAD_TILE_M,
+           PYC_ADA_K32WARP_THREAD_TILE_N,
+           PYC_ADA_K32WARP_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k32_wide/kernel.cu

@@ -0,0 +1,388 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_K32W_BLOCK_M 64
+#define PYC_ADA_K32W_BLOCK_N 128
+#define PYC_ADA_K32W_BLOCK_K 32
+#define PYC_ADA_K32W_THREADS_X 16
+#define PYC_ADA_K32W_THREADS_Y 16
+#define PYC_ADA_K32W_THREAD_TILE_M 4
+#define PYC_ADA_K32W_THREAD_TILE_N 8
+#define PYC_ADA_K32W_VEC 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k32w_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float shared_a[PYC_ADA_K32W_BLOCK_M][PYC_ADA_K32W_BLOCK_K + 1],
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_K32W_BLOCK_K / PYC_ADA_K32W_VEC;
+    const int total_vecs = (PYC_ADA_K32W_BLOCK_M * PYC_ADA_K32W_BLOCK_K) / PYC_ADA_K32W_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K32W_THREADS_X * PYC_ADA_K32W_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K32W_THREADS_X * PYC_ADA_K32W_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K32W_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (global_row < m && global_col + (PYC_ADA_K32W_VEC - 1) < k) {
+            const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+            shared_a[tile_row][tile_col + 0] = value.x;
+            shared_a[tile_row][tile_col + 1] = value.y;
+            shared_a[tile_row][tile_col + 2] = value.z;
+            shared_a[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K32W_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float shared_b[PYC_ADA_K32W_BLOCK_K][PYC_ADA_K32W_BLOCK_N + 1],
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_K32W_BLOCK_N / PYC_ADA_K32W_VEC;
+    const int total_vecs = (PYC_ADA_K32W_BLOCK_K * PYC_ADA_K32W_BLOCK_N) / PYC_ADA_K32W_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K32W_THREADS_X * PYC_ADA_K32W_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K32W_THREADS_X * PYC_ADA_K32W_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K32W_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (global_row < k && global_col + (PYC_ADA_K32W_VEC - 1) < n) {
+            const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+            shared_b[tile_row][tile_col + 0] = value.x;
+            shared_b[tile_row][tile_col + 1] = value.y;
+            shared_b[tile_row][tile_col + 2] = value.z;
+            shared_b[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K32W_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K32W_THREADS_X * PYC_ADA_K32W_THREADS_Y, 2)
+__global__ void ada_fp32_k32w_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float shared_a[PYC_ADA_K32W_BLOCK_M][PYC_ADA_K32W_BLOCK_K + 1];
+    __shared__ float shared_b[PYC_ADA_K32W_BLOCK_K][PYC_ADA_K32W_BLOCK_N + 1];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K32W_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K32W_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K32W_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K32W_THREAD_TILE_N;
+    float accum[PYC_ADA_K32W_THREAD_TILE_M][PYC_ADA_K32W_THREAD_TILE_N];
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_K32W_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_K32W_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K32W_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K32W_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_K32W_THREAD_TILE_M];
+            float b_frag[PYC_ADA_K32W_THREAD_TILE_N];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K32W_THREAD_TILE_M; ++ii) {
+                a_frag[ii] = shared_a[row_fragment + ii][i];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K32W_THREAD_TILE_N; ++ii) {
+                b_frag[ii] = shared_b[i][col_fragment + ii];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K32W_THREAD_TILE_M; ++ii) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_K32W_THREAD_TILE_N; ++jj) {
+                    accum[ii][jj] += a_frag[ii] * b_frag[jj];
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_K32W_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        for (j = 0; j < PYC_ADA_K32W_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k32w_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k32w_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k32w_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K32W_THREADS_X, PYC_ADA_K32W_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K32W_BLOCK_N - 1) / PYC_ADA_K32W_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K32W_BLOCK_M - 1) / PYC_ADA_K32W_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k32w_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k32w_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K32W_BLOCK_M,
+           PYC_ADA_K32W_BLOCK_N,
+           PYC_ADA_K32W_BLOCK_K,
+           PYC_ADA_K32W_THREADS_X,
+           PYC_ADA_K32W_THREADS_Y,
+           PYC_ADA_K32W_THREAD_TILE_M,
+           PYC_ADA_K32W_THREAD_TILE_N,
+           PYC_ADA_K32W_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k64_t44/kernel.cu

@@ -0,0 +1,400 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_K64T44_BLOCK_M 64
+#define PYC_ADA_K64T44_BLOCK_N 64
+#define PYC_ADA_K64T44_BLOCK_K 64
+#define PYC_ADA_K64T44_THREADS_X 16
+#define PYC_ADA_K64T44_THREADS_Y 16
+#define PYC_ADA_K64T44_THREAD_TILE_M 4
+#define PYC_ADA_K64T44_THREAD_TILE_N 4
+#define PYC_ADA_K64T44_VEC 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k64t44_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float shared_a[PYC_ADA_K64T44_BLOCK_M][PYC_ADA_K64T44_BLOCK_K + 1],
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_K64T44_BLOCK_K / PYC_ADA_K64T44_VEC;
+    const int total_vecs = (PYC_ADA_K64T44_BLOCK_M * PYC_ADA_K64T44_BLOCK_K) / PYC_ADA_K64T44_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64T44_THREADS_X * PYC_ADA_K64T44_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64T44_THREADS_X * PYC_ADA_K64T44_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64T44_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (global_row < m && global_col + (PYC_ADA_K64T44_VEC - 1) < k) {
+            const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+            shared_a[tile_row][tile_col + 0] = value.x;
+            shared_a[tile_row][tile_col + 1] = value.y;
+            shared_a[tile_row][tile_col + 2] = value.z;
+            shared_a[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64T44_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float shared_b[PYC_ADA_K64T44_BLOCK_K][PYC_ADA_K64T44_BLOCK_N + 1],
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_K64T44_BLOCK_N / PYC_ADA_K64T44_VEC;
+    const int total_vecs = (PYC_ADA_K64T44_BLOCK_K * PYC_ADA_K64T44_BLOCK_N) / PYC_ADA_K64T44_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64T44_THREADS_X * PYC_ADA_K64T44_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64T44_THREADS_X * PYC_ADA_K64T44_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64T44_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (global_row < k && global_col + (PYC_ADA_K64T44_VEC - 1) < n) {
+            const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+            shared_b[tile_row][tile_col + 0] = value.x;
+            shared_b[tile_row][tile_col + 1] = value.y;
+            shared_b[tile_row][tile_col + 2] = value.z;
+            shared_b[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64T44_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K64T44_THREADS_X * PYC_ADA_K64T44_THREADS_Y, 2)
+__global__ void ada_fp32_k64t44_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float shared_a[PYC_ADA_K64T44_BLOCK_M][PYC_ADA_K64T44_BLOCK_K + 1];
+    __shared__ float shared_b[PYC_ADA_K64T44_BLOCK_K][PYC_ADA_K64T44_BLOCK_N + 1];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K64T44_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K64T44_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K64T44_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K64T44_THREAD_TILE_N;
+    float accum[PYC_ADA_K64T44_THREAD_TILE_M][PYC_ADA_K64T44_THREAD_TILE_N];
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_K64T44_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_K64T44_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K64T44_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K64T44_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_K64T44_THREAD_TILE_M];
+            float b_frag[PYC_ADA_K64T44_THREAD_TILE_N];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64T44_THREAD_TILE_M; ++ii) {
+                a_frag[ii] = shared_a[row_fragment + ii][i];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64T44_THREAD_TILE_N; ++ii) {
+                b_frag[ii] = shared_b[i][col_fragment + ii];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64T44_THREAD_TILE_M; ++ii) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_K64T44_THREAD_TILE_N; ++jj) {
+                    accum[ii][jj] = fmaf(a_frag[ii], b_frag[jj], accum[ii][jj]);
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_K64T44_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        if (col_fragment + 3 < PYC_ADA_K64T44_BLOCK_N) {
+            int out_col = block_col + col_fragment;
+            if (out_col + 3 < n) {
+                float4 value;
+                value.x = accum[i][0];
+                value.y = accum[i][1];
+                value.z = accum[i][2];
+                value.w = accum[i][3];
+                *reinterpret_cast<float4*>(&c[out_row * n + out_col]) = value;
+                continue;
+            }
+        }
+        for (j = 0; j < PYC_ADA_K64T44_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k64t44_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k64t44_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k64t44_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K64T44_THREADS_X, PYC_ADA_K64T44_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K64T44_BLOCK_N - 1) / PYC_ADA_K64T44_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K64T44_BLOCK_M - 1) / PYC_ADA_K64T44_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k64t44_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k64t44_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K64T44_BLOCK_M,
+           PYC_ADA_K64T44_BLOCK_N,
+           PYC_ADA_K64T44_BLOCK_K,
+           PYC_ADA_K64T44_THREADS_X,
+           PYC_ADA_K64T44_THREADS_Y,
+           PYC_ADA_K64T44_THREAD_TILE_M,
+           PYC_ADA_K64T44_THREAD_TILE_N,
+           PYC_ADA_K64T44_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k64_warp32/kernel.cu

@@ -0,0 +1,388 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_K64WARP_BLOCK_M 64
+#define PYC_ADA_K64WARP_BLOCK_N 64
+#define PYC_ADA_K64WARP_BLOCK_K 64
+#define PYC_ADA_K64WARP_THREADS_X 32
+#define PYC_ADA_K64WARP_THREADS_Y 8
+#define PYC_ADA_K64WARP_THREAD_TILE_M 8
+#define PYC_ADA_K64WARP_THREAD_TILE_N 2
+#define PYC_ADA_K64WARP_VEC 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k64warp_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float shared_a[PYC_ADA_K64WARP_BLOCK_M][PYC_ADA_K64WARP_BLOCK_K + 1],
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_K64WARP_BLOCK_K / PYC_ADA_K64WARP_VEC;
+    const int total_vecs = (PYC_ADA_K64WARP_BLOCK_M * PYC_ADA_K64WARP_BLOCK_K) / PYC_ADA_K64WARP_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64WARP_THREADS_X * PYC_ADA_K64WARP_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64WARP_THREADS_X * PYC_ADA_K64WARP_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64WARP_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (global_row < m && global_col + (PYC_ADA_K64WARP_VEC - 1) < k) {
+            const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+            shared_a[tile_row][tile_col + 0] = value.x;
+            shared_a[tile_row][tile_col + 1] = value.y;
+            shared_a[tile_row][tile_col + 2] = value.z;
+            shared_a[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64WARP_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float shared_b[PYC_ADA_K64WARP_BLOCK_K][PYC_ADA_K64WARP_BLOCK_N + 1],
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_K64WARP_BLOCK_N / PYC_ADA_K64WARP_VEC;
+    const int total_vecs = (PYC_ADA_K64WARP_BLOCK_K * PYC_ADA_K64WARP_BLOCK_N) / PYC_ADA_K64WARP_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64WARP_THREADS_X * PYC_ADA_K64WARP_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64WARP_THREADS_X * PYC_ADA_K64WARP_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64WARP_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (global_row < k && global_col + (PYC_ADA_K64WARP_VEC - 1) < n) {
+            const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+            shared_b[tile_row][tile_col + 0] = value.x;
+            shared_b[tile_row][tile_col + 1] = value.y;
+            shared_b[tile_row][tile_col + 2] = value.z;
+            shared_b[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64WARP_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K64WARP_THREADS_X * PYC_ADA_K64WARP_THREADS_Y, 2)
+__global__ void ada_fp32_k64warp_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float shared_a[PYC_ADA_K64WARP_BLOCK_M][PYC_ADA_K64WARP_BLOCK_K + 1];
+    __shared__ float shared_b[PYC_ADA_K64WARP_BLOCK_K][PYC_ADA_K64WARP_BLOCK_N + 1];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K64WARP_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K64WARP_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K64WARP_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K64WARP_THREAD_TILE_N;
+    float accum[PYC_ADA_K64WARP_THREAD_TILE_M][PYC_ADA_K64WARP_THREAD_TILE_N];
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_K64WARP_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_K64WARP_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K64WARP_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K64WARP_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_K64WARP_THREAD_TILE_M];
+            float b_frag[PYC_ADA_K64WARP_THREAD_TILE_N];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64WARP_THREAD_TILE_M; ++ii) {
+                a_frag[ii] = shared_a[row_fragment + ii][i];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64WARP_THREAD_TILE_N; ++ii) {
+                b_frag[ii] = shared_b[i][col_fragment + ii];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64WARP_THREAD_TILE_M; ++ii) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_K64WARP_THREAD_TILE_N; ++jj) {
+                    accum[ii][jj] += a_frag[ii] * b_frag[jj];
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_K64WARP_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        for (j = 0; j < PYC_ADA_K64WARP_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k64warp_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k64warp_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k64warp_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K64WARP_THREADS_X, PYC_ADA_K64WARP_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K64WARP_BLOCK_N - 1) / PYC_ADA_K64WARP_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K64WARP_BLOCK_M - 1) / PYC_ADA_K64WARP_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k64warp_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k64warp_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K64WARP_BLOCK_M,
+           PYC_ADA_K64WARP_BLOCK_N,
+           PYC_ADA_K64WARP_BLOCK_K,
+           PYC_ADA_K64WARP_THREADS_X,
+           PYC_ADA_K64WARP_THREADS_Y,
+           PYC_ADA_K64WARP_THREAD_TILE_M,
+           PYC_ADA_K64WARP_THREAD_TILE_N,
+           PYC_ADA_K64WARP_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k64_warp32_acc2/kernel.cu

@@ -0,0 +1,404 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_K64A2_BLOCK_M 64
+#define PYC_ADA_K64A2_BLOCK_N 64
+#define PYC_ADA_K64A2_BLOCK_K 64
+#define PYC_ADA_K64A2_THREADS_X 32
+#define PYC_ADA_K64A2_THREADS_Y 8
+#define PYC_ADA_K64A2_THREAD_TILE_M 8
+#define PYC_ADA_K64A2_THREAD_TILE_N 2
+#define PYC_ADA_K64A2_VEC 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k64a2_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float shared_a[PYC_ADA_K64A2_BLOCK_M][PYC_ADA_K64A2_BLOCK_K + 1],
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_K64A2_BLOCK_K / PYC_ADA_K64A2_VEC;
+    const int total_vecs = (PYC_ADA_K64A2_BLOCK_M * PYC_ADA_K64A2_BLOCK_K) / PYC_ADA_K64A2_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64A2_THREADS_X * PYC_ADA_K64A2_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64A2_THREADS_X * PYC_ADA_K64A2_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64A2_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (global_row < m && global_col + (PYC_ADA_K64A2_VEC - 1) < k) {
+            const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+            shared_a[tile_row][tile_col + 0] = value.x;
+            shared_a[tile_row][tile_col + 1] = value.y;
+            shared_a[tile_row][tile_col + 2] = value.z;
+            shared_a[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64A2_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float shared_b[PYC_ADA_K64A2_BLOCK_K][PYC_ADA_K64A2_BLOCK_N + 1],
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_K64A2_BLOCK_N / PYC_ADA_K64A2_VEC;
+    const int total_vecs = (PYC_ADA_K64A2_BLOCK_K * PYC_ADA_K64A2_BLOCK_N) / PYC_ADA_K64A2_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64A2_THREADS_X * PYC_ADA_K64A2_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64A2_THREADS_X * PYC_ADA_K64A2_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64A2_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (global_row < k && global_col + (PYC_ADA_K64A2_VEC - 1) < n) {
+            const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+            shared_b[tile_row][tile_col + 0] = value.x;
+            shared_b[tile_row][tile_col + 1] = value.y;
+            shared_b[tile_row][tile_col + 2] = value.z;
+            shared_b[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64A2_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K64A2_THREADS_X * PYC_ADA_K64A2_THREADS_Y, 2)
+__global__ void ada_fp32_k64a2_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float shared_a[PYC_ADA_K64A2_BLOCK_M][PYC_ADA_K64A2_BLOCK_K + 1];
+    __shared__ float shared_b[PYC_ADA_K64A2_BLOCK_K][PYC_ADA_K64A2_BLOCK_N + 1];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K64A2_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K64A2_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K64A2_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K64A2_THREAD_TILE_N;
+    float accum0[PYC_ADA_K64A2_THREAD_TILE_M];
+    float accum1[PYC_ADA_K64A2_THREAD_TILE_M];
+    int kk_base;
+    int i;
+
+    #pragma unroll
+    for (i = 0; i < PYC_ADA_K64A2_THREAD_TILE_M; ++i) {
+        accum0[i] = 0.0f;
+        accum1[i] = 0.0f;
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K64A2_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K64A2_BLOCK_K; ++i) {
+            const float b0 = shared_b[i][col_fragment + 0];
+            const float b1 = shared_b[i][col_fragment + 1];
+            const float a0 = shared_a[row_fragment + 0][i];
+            const float a1 = shared_a[row_fragment + 1][i];
+            const float a2 = shared_a[row_fragment + 2][i];
+            const float a3 = shared_a[row_fragment + 3][i];
+            const float a4 = shared_a[row_fragment + 4][i];
+            const float a5 = shared_a[row_fragment + 5][i];
+            const float a6 = shared_a[row_fragment + 6][i];
+            const float a7 = shared_a[row_fragment + 7][i];
+
+            accum0[0] = fmaf(a0, b0, accum0[0]);
+            accum1[0] = fmaf(a0, b1, accum1[0]);
+            accum0[1] = fmaf(a1, b0, accum0[1]);
+            accum1[1] = fmaf(a1, b1, accum1[1]);
+            accum0[2] = fmaf(a2, b0, accum0[2]);
+            accum1[2] = fmaf(a2, b1, accum1[2]);
+            accum0[3] = fmaf(a3, b0, accum0[3]);
+            accum1[3] = fmaf(a3, b1, accum1[3]);
+            accum0[4] = fmaf(a4, b0, accum0[4]);
+            accum1[4] = fmaf(a4, b1, accum1[4]);
+            accum0[5] = fmaf(a5, b0, accum0[5]);
+            accum1[5] = fmaf(a5, b1, accum1[5]);
+            accum0[6] = fmaf(a6, b0, accum0[6]);
+            accum1[6] = fmaf(a6, b1, accum1[6]);
+            accum0[7] = fmaf(a7, b0, accum0[7]);
+            accum1[7] = fmaf(a7, b1, accum1[7]);
+        }
+
+        __syncthreads();
+    }
+
+    #pragma unroll
+    for (i = 0; i < PYC_ADA_K64A2_THREAD_TILE_M; ++i) {
+        const int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        if (col_fragment + 1 < PYC_ADA_K64A2_BLOCK_N) {
+            const int out_col = block_col + col_fragment;
+            if (out_col + 1 < n) {
+                float2 value;
+                value.x = accum0[i];
+                value.y = accum1[i];
+                *reinterpret_cast<float2*>(&c[out_row * n + out_col]) = value;
+                continue;
+            }
+        }
+        if (block_col + col_fragment + 0 < n) {
+            c[out_row * n + block_col + col_fragment + 0] = accum0[i];
+        }
+        if (block_col + col_fragment + 1 < n) {
+            c[out_row * n + block_col + col_fragment + 1] = accum1[i];
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k64a2_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k64a2_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k64a2_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K64A2_THREADS_X, PYC_ADA_K64A2_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K64A2_BLOCK_N - 1) / PYC_ADA_K64A2_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K64A2_BLOCK_M - 1) / PYC_ADA_K64A2_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k64a2_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k64a2_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K64A2_BLOCK_M,
+           PYC_ADA_K64A2_BLOCK_N,
+           PYC_ADA_K64A2_BLOCK_K,
+           PYC_ADA_K64A2_THREADS_X,
+           PYC_ADA_K64A2_THREADS_Y,
+           PYC_ADA_K64A2_THREAD_TILE_M,
+           PYC_ADA_K64A2_THREAD_TILE_N,
+           PYC_ADA_K64A2_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k64_warp32_async/kernel.cu

@@ -0,0 +1,505 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define PYC_ADA_K64ASYNC_BLOCK_M 64
+#define PYC_ADA_K64ASYNC_BLOCK_N 64
+#define PYC_ADA_K64ASYNC_BLOCK_K 64
+#define PYC_ADA_K64ASYNC_THREADS_X 32
+#define PYC_ADA_K64ASYNC_THREADS_Y 8
+#define PYC_ADA_K64ASYNC_THREAD_TILE_M 8
+#define PYC_ADA_K64ASYNC_THREAD_TILE_N 2
+#define PYC_ADA_K64ASYNC_VEC 4
+#define PYC_ADA_K64ASYNC_STAGES 2
+#define PYC_ADA_K64ASYNC_SHARED_STRIDE_A (PYC_ADA_K64ASYNC_BLOCK_K + 4)
+#define PYC_ADA_K64ASYNC_SHARED_STRIDE_B (PYC_ADA_K64ASYNC_BLOCK_N + 4)
+#define PYC_ADA_K64ASYNC_STAGE_A_ELEMS (PYC_ADA_K64ASYNC_BLOCK_M * PYC_ADA_K64ASYNC_SHARED_STRIDE_A)
+#define PYC_ADA_K64ASYNC_STAGE_B_ELEMS (PYC_ADA_K64ASYNC_BLOCK_K * PYC_ADA_K64ASYNC_SHARED_STRIDE_B)
+#define PYC_ADA_K64ASYNC_SHARED_ELEMS (PYC_ADA_K64ASYNC_STAGES * (PYC_ADA_K64ASYNC_STAGE_A_ELEMS + PYC_ADA_K64ASYNC_STAGE_B_ELEMS))
+#define PYC_ADA_K64ASYNC_SHARED_BYTES (PYC_ADA_K64ASYNC_SHARED_ELEMS * (int)sizeof(float))
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k64async_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static double wall_ms_now(void) {
+    struct timespec ts;
+    timespec_get(&ts, TIME_UTC);
+    return ((double)ts.tv_sec * 1000.0) + ((double)ts.tv_nsec / 1000000.0);
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static __forceinline__ void async_copy_16(void* dst, const void* src) {
+#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
+    unsigned int smem_addr = (unsigned int)__cvta_generic_to_shared(dst);
+    asm volatile("cp.async.ca.shared.global [%0], [%1], 16;\n" :: "r"(smem_addr), "l"(src));
+#else
+    *reinterpret_cast<float4*>(dst) = *reinterpret_cast<const float4*>(src);
+#endif
+}
+
+__device__ static __forceinline__ void async_commit(void) {
+#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
+    asm volatile("cp.async.commit_group;" ::: "memory");
+#endif
+}
+
+__device__ static __forceinline__ void async_wait(void) {
+#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
+    asm volatile("cp.async.wait_group 0;" ::: "memory");
+#endif
+}
+
+__device__ static __forceinline__ float* shared_stage_a(float* shared_mem, int stage) {
+    return shared_mem + stage * (PYC_ADA_K64ASYNC_STAGE_A_ELEMS + PYC_ADA_K64ASYNC_STAGE_B_ELEMS);
+}
+
+__device__ static __forceinline__ float* shared_stage_b(float* shared_mem, int stage) {
+    return shared_stage_a(shared_mem, stage) + PYC_ADA_K64ASYNC_STAGE_A_ELEMS;
+}
+
+__device__ static __forceinline__ float shared_a_load(const float* shared_a, int row, int col) {
+    return shared_a[row * PYC_ADA_K64ASYNC_SHARED_STRIDE_A + col];
+}
+
+__device__ static __forceinline__ float shared_b_load(const float* shared_b, int row, int col) {
+    return shared_b[row * PYC_ADA_K64ASYNC_SHARED_STRIDE_B + col];
+}
+
+__device__ static __forceinline__ void shared_a_store(float* shared_a, int row, int col, float value) {
+    shared_a[row * PYC_ADA_K64ASYNC_SHARED_STRIDE_A + col] = value;
+}
+
+__device__ static __forceinline__ void shared_b_store(float* shared_b, int row, int col, float value) {
+    shared_b[row * PYC_ADA_K64ASYNC_SHARED_STRIDE_B + col] = value;
+}
+
+__device__ static void load_a_stage(
+    const float* __restrict__ a,
+    float* shared_a,
+    int stage,
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int block_threads = PYC_ADA_K64ASYNC_THREADS_X * PYC_ADA_K64ASYNC_THREADS_Y;
+    const int vecs_per_row = PYC_ADA_K64ASYNC_BLOCK_K / PYC_ADA_K64ASYNC_VEC;
+    const int total_vecs = (PYC_ADA_K64ASYNC_BLOCK_M * PYC_ADA_K64ASYNC_BLOCK_K) / PYC_ADA_K64ASYNC_VEC;
+    const int full_tile = (block_row + PYC_ADA_K64ASYNC_BLOCK_M <= m) &&
+                          (kk_base + PYC_ADA_K64ASYNC_BLOCK_K <= k) &&
+                          ((k & (PYC_ADA_K64ASYNC_VEC - 1)) == 0);
+    int phase;
+
+    for (phase = 0; phase < total_vecs / block_threads; ++phase) {
+        const int linear = lane_linear + phase * block_threads;
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64ASYNC_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (full_tile) {
+            async_copy_16(
+                &shared_a[tile_row * PYC_ADA_K64ASYNC_SHARED_STRIDE_A + tile_col],
+                &a[global_row * k + global_col]);
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64ASYNC_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a_store(shared_a, tile_row, tile_col + i, value);
+        }
+    }
+}
+
+__device__ static void load_b_stage(
+    const float* __restrict__ b,
+    float* shared_b,
+    int stage,
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int block_threads = PYC_ADA_K64ASYNC_THREADS_X * PYC_ADA_K64ASYNC_THREADS_Y;
+    const int vecs_per_row = PYC_ADA_K64ASYNC_BLOCK_N / PYC_ADA_K64ASYNC_VEC;
+    const int total_vecs = (PYC_ADA_K64ASYNC_BLOCK_K * PYC_ADA_K64ASYNC_BLOCK_N) / PYC_ADA_K64ASYNC_VEC;
+    const int full_tile = (block_col + PYC_ADA_K64ASYNC_BLOCK_N <= n) &&
+                          (kk_base + PYC_ADA_K64ASYNC_BLOCK_K <= k) &&
+                          ((n & (PYC_ADA_K64ASYNC_VEC - 1)) == 0);
+    int phase;
+
+    for (phase = 0; phase < total_vecs / block_threads; ++phase) {
+        const int linear = lane_linear + phase * block_threads;
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64ASYNC_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (full_tile) {
+            async_copy_16(
+                &shared_b[tile_row * PYC_ADA_K64ASYNC_SHARED_STRIDE_B + tile_col],
+                &b[global_row * n + global_col]);
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64ASYNC_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b_store(shared_b, tile_row, tile_col + i, value);
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K64ASYNC_THREADS_X * PYC_ADA_K64ASYNC_THREADS_Y, 2)
+__global__ void ada_fp32_k64async_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    extern __shared__ __align__(16) float shared_mem[];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K64ASYNC_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K64ASYNC_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K64ASYNC_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K64ASYNC_THREAD_TILE_N;
+    float accum[PYC_ADA_K64ASYNC_THREAD_TILE_M][PYC_ADA_K64ASYNC_THREAD_TILE_N];
+    int kk_base;
+    int stage;
+    int next_stage;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_K64ASYNC_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_K64ASYNC_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    stage = 0;
+    load_a_stage(a, shared_stage_a(shared_mem, stage), stage, lane_linear, block_row, 0, m, k);
+    load_b_stage(b, shared_stage_b(shared_mem, stage), stage, lane_linear, block_col, 0, k, n);
+    async_commit();
+    async_wait();
+    __syncthreads();
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K64ASYNC_BLOCK_K) {
+        const int next_kk = kk_base + PYC_ADA_K64ASYNC_BLOCK_K;
+
+        next_stage = stage ^ 1;
+        if (next_kk < k) {
+            load_a_stage(a, shared_stage_a(shared_mem, next_stage), next_stage, lane_linear, block_row, next_kk, m, k);
+            load_b_stage(b, shared_stage_b(shared_mem, next_stage), next_stage, lane_linear, block_col, next_kk, k, n);
+            async_commit();
+        }
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K64ASYNC_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_K64ASYNC_THREAD_TILE_M];
+            float b_frag[PYC_ADA_K64ASYNC_THREAD_TILE_N];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64ASYNC_THREAD_TILE_M; ++ii) {
+                a_frag[ii] = shared_a_load(shared_stage_a(shared_mem, stage), row_fragment + ii, i);
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64ASYNC_THREAD_TILE_N; ++ii) {
+                b_frag[ii] = shared_b_load(shared_stage_b(shared_mem, stage), i, col_fragment + ii);
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64ASYNC_THREAD_TILE_M; ++ii) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_K64ASYNC_THREAD_TILE_N; ++jj) {
+                    accum[ii][jj] = fmaf(a_frag[ii], b_frag[jj], accum[ii][jj]);
+                }
+            }
+        }
+
+        __syncthreads();
+        if (next_kk < k) {
+            async_wait();
+            __syncthreads();
+            stage = next_stage;
+        }
+    }
+
+    for (i = 0; i < PYC_ADA_K64ASYNC_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        if (col_fragment + 1 < PYC_ADA_K64ASYNC_BLOCK_N) {
+            int out_col = block_col + col_fragment;
+            if (out_col + 1 < n) {
+                float2 value;
+                value.x = accum[i][0];
+                value.y = accum[i][1];
+                *reinterpret_cast<float2*>(&c[out_row * n + out_col]) = value;
+                continue;
+            }
+        }
+        for (j = 0; j < PYC_ADA_K64ASYNC_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k64async_gemm,
+        cudaFuncAttributeMaxDynamicSharedMemorySize,
+        PYC_ADA_K64ASYNC_SHARED_BYTES);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute(max_dynamic_shared) failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k64async_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k64async_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k64async_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    double best_wall_ms = 0.0;
+    double wall_sum_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K64ASYNC_THREADS_X, PYC_ADA_K64ASYNC_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K64ASYNC_BLOCK_N - 1) / PYC_ADA_K64ASYNC_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K64ASYNC_BLOCK_M - 1) / PYC_ADA_K64ASYNC_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k64async_gemm<<<grid, block, PYC_ADA_K64ASYNC_SHARED_BYTES>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    best_wall_ms = 0.0;
+    wall_sum_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        double wall_start_ms = wall_ms_now();
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k64async_gemm<<<grid, block, PYC_ADA_K64ASYNC_SHARED_BYTES>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        {
+            double wall_elapsed_ms = wall_ms_now() - wall_start_ms;
+            wall_sum_ms += wall_elapsed_ms;
+            if (iter == 0 || wall_elapsed_ms < best_wall_ms) {
+                best_wall_ms = wall_elapsed_ms;
+            }
+        }
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K64ASYNC_BLOCK_M,
+           PYC_ADA_K64ASYNC_BLOCK_N,
+           PYC_ADA_K64ASYNC_BLOCK_K,
+           PYC_ADA_K64ASYNC_THREADS_X,
+           PYC_ADA_K64ASYNC_THREADS_Y,
+           PYC_ADA_K64ASYNC_THREAD_TILE_M,
+           PYC_ADA_K64ASYNC_THREAD_TILE_N,
+           PYC_ADA_K64ASYNC_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    if (cfg.iters > 0) {
+        printf("best_wall_ms=%.3f\n", best_wall_ms);
+        printf("mean_wall_ms=%.3f\n", wall_sum_ms / (double)cfg.iters);
+    }
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k64_warp32_ilp2/kernel.cu

@@ -0,0 +1,397 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_K64ILP2_BLOCK_M 64
+#define PYC_ADA_K64ILP2_BLOCK_N 64
+#define PYC_ADA_K64ILP2_BLOCK_K 64
+#define PYC_ADA_K64ILP2_THREADS_X 32
+#define PYC_ADA_K64ILP2_THREADS_Y 8
+#define PYC_ADA_K64ILP2_THREAD_TILE_M 8
+#define PYC_ADA_K64ILP2_THREAD_TILE_N 2
+#define PYC_ADA_K64ILP2_VEC 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k64ilp2_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float shared_a[PYC_ADA_K64ILP2_BLOCK_M][PYC_ADA_K64ILP2_BLOCK_K + 1],
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_K64ILP2_BLOCK_K / PYC_ADA_K64ILP2_VEC;
+    const int total_vecs = (PYC_ADA_K64ILP2_BLOCK_M * PYC_ADA_K64ILP2_BLOCK_K) / PYC_ADA_K64ILP2_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64ILP2_THREADS_X * PYC_ADA_K64ILP2_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64ILP2_THREADS_X * PYC_ADA_K64ILP2_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64ILP2_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (global_row < m && global_col + (PYC_ADA_K64ILP2_VEC - 1) < k) {
+            const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+            shared_a[tile_row][tile_col + 0] = value.x;
+            shared_a[tile_row][tile_col + 1] = value.y;
+            shared_a[tile_row][tile_col + 2] = value.z;
+            shared_a[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64ILP2_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float shared_b[PYC_ADA_K64ILP2_BLOCK_K][PYC_ADA_K64ILP2_BLOCK_N + 1],
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_K64ILP2_BLOCK_N / PYC_ADA_K64ILP2_VEC;
+    const int total_vecs = (PYC_ADA_K64ILP2_BLOCK_K * PYC_ADA_K64ILP2_BLOCK_N) / PYC_ADA_K64ILP2_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64ILP2_THREADS_X * PYC_ADA_K64ILP2_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64ILP2_THREADS_X * PYC_ADA_K64ILP2_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64ILP2_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (global_row < k && global_col + (PYC_ADA_K64ILP2_VEC - 1) < n) {
+            const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+            shared_b[tile_row][tile_col + 0] = value.x;
+            shared_b[tile_row][tile_col + 1] = value.y;
+            shared_b[tile_row][tile_col + 2] = value.z;
+            shared_b[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64ILP2_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K64ILP2_THREADS_X * PYC_ADA_K64ILP2_THREADS_Y, 2)
+__global__ void ada_fp32_k64ilp2_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float shared_a[PYC_ADA_K64ILP2_BLOCK_M][PYC_ADA_K64ILP2_BLOCK_K + 1];
+    __shared__ float shared_b[PYC_ADA_K64ILP2_BLOCK_K][PYC_ADA_K64ILP2_BLOCK_N + 1];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K64ILP2_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K64ILP2_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K64ILP2_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K64ILP2_THREAD_TILE_N;
+    float accum[PYC_ADA_K64ILP2_THREAD_TILE_M][PYC_ADA_K64ILP2_THREAD_TILE_N];
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_K64ILP2_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_K64ILP2_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K64ILP2_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K64ILP2_BLOCK_K; i += 2) {
+            float a_frag0[PYC_ADA_K64ILP2_THREAD_TILE_M];
+            float a_frag1[PYC_ADA_K64ILP2_THREAD_TILE_M];
+            const float b0_0 = shared_b[i + 0][col_fragment + 0];
+            const float b0_1 = shared_b[i + 0][col_fragment + 1];
+            const float b1_0 = shared_b[i + 1][col_fragment + 0];
+            const float b1_1 = shared_b[i + 1][col_fragment + 1];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64ILP2_THREAD_TILE_M; ++ii) {
+                a_frag0[ii] = shared_a[row_fragment + ii][i + 0];
+                a_frag1[ii] = shared_a[row_fragment + ii][i + 1];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64ILP2_THREAD_TILE_M; ++ii) {
+                accum[ii][0] = fmaf(a_frag0[ii], b0_0, accum[ii][0]);
+                accum[ii][1] = fmaf(a_frag0[ii], b0_1, accum[ii][1]);
+                accum[ii][0] = fmaf(a_frag1[ii], b1_0, accum[ii][0]);
+                accum[ii][1] = fmaf(a_frag1[ii], b1_1, accum[ii][1]);
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_K64ILP2_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        if (col_fragment + 1 < PYC_ADA_K64ILP2_BLOCK_N) {
+            int out_col = block_col + col_fragment;
+            if (out_col + 1 < n) {
+                float2 value;
+                value.x = accum[i][0];
+                value.y = accum[i][1];
+                *reinterpret_cast<float2*>(&c[out_row * n + out_col]) = value;
+                continue;
+            }
+        }
+        for (j = 0; j < PYC_ADA_K64ILP2_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k64ilp2_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k64ilp2_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k64ilp2_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K64ILP2_THREADS_X, PYC_ADA_K64ILP2_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K64ILP2_BLOCK_N - 1) / PYC_ADA_K64ILP2_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K64ILP2_BLOCK_M - 1) / PYC_ADA_K64ILP2_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k64ilp2_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k64ilp2_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K64ILP2_BLOCK_M,
+           PYC_ADA_K64ILP2_BLOCK_N,
+           PYC_ADA_K64ILP2_BLOCK_K,
+           PYC_ADA_K64ILP2_THREADS_X,
+           PYC_ADA_K64ILP2_THREADS_Y,
+           PYC_ADA_K64ILP2_THREAD_TILE_M,
+           PYC_ADA_K64ILP2_THREAD_TILE_N,
+           PYC_ADA_K64ILP2_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k64_warp32_lb1/kernel.cu

@@ -0,0 +1,388 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_K64LB1_BLOCK_M 64
+#define PYC_ADA_K64LB1_BLOCK_N 64
+#define PYC_ADA_K64LB1_BLOCK_K 64
+#define PYC_ADA_K64LB1_THREADS_X 32
+#define PYC_ADA_K64LB1_THREADS_Y 8
+#define PYC_ADA_K64LB1_THREAD_TILE_M 8
+#define PYC_ADA_K64LB1_THREAD_TILE_N 2
+#define PYC_ADA_K64LB1_VEC 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k64lb1_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float shared_a[PYC_ADA_K64LB1_BLOCK_M][PYC_ADA_K64LB1_BLOCK_K + 1],
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_K64LB1_BLOCK_K / PYC_ADA_K64LB1_VEC;
+    const int total_vecs = (PYC_ADA_K64LB1_BLOCK_M * PYC_ADA_K64LB1_BLOCK_K) / PYC_ADA_K64LB1_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64LB1_THREADS_X * PYC_ADA_K64LB1_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64LB1_THREADS_X * PYC_ADA_K64LB1_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64LB1_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (global_row < m && global_col + (PYC_ADA_K64LB1_VEC - 1) < k) {
+            const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+            shared_a[tile_row][tile_col + 0] = value.x;
+            shared_a[tile_row][tile_col + 1] = value.y;
+            shared_a[tile_row][tile_col + 2] = value.z;
+            shared_a[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64LB1_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float shared_b[PYC_ADA_K64LB1_BLOCK_K][PYC_ADA_K64LB1_BLOCK_N + 1],
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_K64LB1_BLOCK_N / PYC_ADA_K64LB1_VEC;
+    const int total_vecs = (PYC_ADA_K64LB1_BLOCK_K * PYC_ADA_K64LB1_BLOCK_N) / PYC_ADA_K64LB1_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64LB1_THREADS_X * PYC_ADA_K64LB1_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64LB1_THREADS_X * PYC_ADA_K64LB1_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64LB1_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (global_row < k && global_col + (PYC_ADA_K64LB1_VEC - 1) < n) {
+            const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+            shared_b[tile_row][tile_col + 0] = value.x;
+            shared_b[tile_row][tile_col + 1] = value.y;
+            shared_b[tile_row][tile_col + 2] = value.z;
+            shared_b[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64LB1_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K64LB1_THREADS_X * PYC_ADA_K64LB1_THREADS_Y, 1)
+__global__ void ada_fp32_k64lb1_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float shared_a[PYC_ADA_K64LB1_BLOCK_M][PYC_ADA_K64LB1_BLOCK_K + 1];
+    __shared__ float shared_b[PYC_ADA_K64LB1_BLOCK_K][PYC_ADA_K64LB1_BLOCK_N + 1];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K64LB1_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K64LB1_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K64LB1_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K64LB1_THREAD_TILE_N;
+    float accum[PYC_ADA_K64LB1_THREAD_TILE_M][PYC_ADA_K64LB1_THREAD_TILE_N];
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_K64LB1_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_K64LB1_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K64LB1_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K64LB1_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_K64LB1_THREAD_TILE_M];
+            float b_frag[PYC_ADA_K64LB1_THREAD_TILE_N];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64LB1_THREAD_TILE_M; ++ii) {
+                a_frag[ii] = shared_a[row_fragment + ii][i];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64LB1_THREAD_TILE_N; ++ii) {
+                b_frag[ii] = shared_b[i][col_fragment + ii];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64LB1_THREAD_TILE_M; ++ii) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_K64LB1_THREAD_TILE_N; ++jj) {
+                    accum[ii][jj] += a_frag[ii] * b_frag[jj];
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_K64LB1_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        for (j = 0; j < PYC_ADA_K64LB1_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k64lb1_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k64lb1_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k64lb1_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K64LB1_THREADS_X, PYC_ADA_K64LB1_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K64LB1_BLOCK_N - 1) / PYC_ADA_K64LB1_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K64LB1_BLOCK_M - 1) / PYC_ADA_K64LB1_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k64lb1_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k64lb1_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K64LB1_BLOCK_M,
+           PYC_ADA_K64LB1_BLOCK_N,
+           PYC_ADA_K64LB1_BLOCK_K,
+           PYC_ADA_K64LB1_THREADS_X,
+           PYC_ADA_K64LB1_THREADS_Y,
+           PYC_ADA_K64LB1_THREAD_TILE_M,
+           PYC_ADA_K64LB1_THREAD_TILE_N,
+           PYC_ADA_K64LB1_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_k64_warp32_store2/kernel.cu

@@ -0,0 +1,398 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_K64S2_BLOCK_M 64
+#define PYC_ADA_K64S2_BLOCK_N 64
+#define PYC_ADA_K64S2_BLOCK_K 64
+#define PYC_ADA_K64S2_THREADS_X 32
+#define PYC_ADA_K64S2_THREADS_Y 8
+#define PYC_ADA_K64S2_THREAD_TILE_M 8
+#define PYC_ADA_K64S2_THREAD_TILE_N 2
+#define PYC_ADA_K64S2_VEC 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_k64s2_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float shared_a[PYC_ADA_K64S2_BLOCK_M][PYC_ADA_K64S2_BLOCK_K + 1],
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_K64S2_BLOCK_K / PYC_ADA_K64S2_VEC;
+    const int total_vecs = (PYC_ADA_K64S2_BLOCK_M * PYC_ADA_K64S2_BLOCK_K) / PYC_ADA_K64S2_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64S2_THREADS_X * PYC_ADA_K64S2_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64S2_THREADS_X * PYC_ADA_K64S2_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64S2_VEC;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (global_row < m && global_col + (PYC_ADA_K64S2_VEC - 1) < k) {
+            const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+            shared_a[tile_row][tile_col + 0] = value.x;
+            shared_a[tile_row][tile_col + 1] = value.y;
+            shared_a[tile_row][tile_col + 2] = value.z;
+            shared_a[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64S2_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float shared_b[PYC_ADA_K64S2_BLOCK_K][PYC_ADA_K64S2_BLOCK_N + 1],
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_K64S2_BLOCK_N / PYC_ADA_K64S2_VEC;
+    const int total_vecs = (PYC_ADA_K64S2_BLOCK_K * PYC_ADA_K64S2_BLOCK_N) / PYC_ADA_K64S2_VEC;
+    int phase;
+
+    for (phase = 0; phase < total_vecs / (PYC_ADA_K64S2_THREADS_X * PYC_ADA_K64S2_THREADS_Y); ++phase) {
+        const int linear = lane_linear + phase * (PYC_ADA_K64S2_THREADS_X * PYC_ADA_K64S2_THREADS_Y);
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_ADA_K64S2_VEC;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (global_row < k && global_col + (PYC_ADA_K64S2_VEC - 1) < n) {
+            const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+            shared_b[tile_row][tile_col + 0] = value.x;
+            shared_b[tile_row][tile_col + 1] = value.y;
+            shared_b[tile_row][tile_col + 2] = value.z;
+            shared_b[tile_row][tile_col + 3] = value.w;
+            continue;
+        }
+
+        for (i = 0; i < PYC_ADA_K64S2_VEC; ++i) {
+            float value = 0.0f;
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b[tile_row][tile_col + i] = value;
+        }
+    }
+}
+
+__launch_bounds__(PYC_ADA_K64S2_THREADS_X * PYC_ADA_K64S2_THREADS_Y, 2)
+__global__ void ada_fp32_k64s2_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float shared_a[PYC_ADA_K64S2_BLOCK_M][PYC_ADA_K64S2_BLOCK_K + 1];
+    __shared__ float shared_b[PYC_ADA_K64S2_BLOCK_K][PYC_ADA_K64S2_BLOCK_N + 1];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_K64S2_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_K64S2_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_K64S2_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_K64S2_THREAD_TILE_N;
+    float accum[PYC_ADA_K64S2_THREAD_TILE_M][PYC_ADA_K64S2_THREAD_TILE_N];
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_K64S2_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_K64S2_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_K64S2_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_K64S2_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_K64S2_THREAD_TILE_M];
+            float b_frag[PYC_ADA_K64S2_THREAD_TILE_N];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64S2_THREAD_TILE_M; ++ii) {
+                a_frag[ii] = shared_a[row_fragment + ii][i];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64S2_THREAD_TILE_N; ++ii) {
+                b_frag[ii] = shared_b[i][col_fragment + ii];
+            }
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_K64S2_THREAD_TILE_M; ++ii) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_K64S2_THREAD_TILE_N; ++jj) {
+                    accum[ii][jj] = fmaf(a_frag[ii], b_frag[jj], accum[ii][jj]);
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_K64S2_THREAD_TILE_M; ++i) {
+        int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        if (col_fragment + 1 < PYC_ADA_K64S2_BLOCK_N) {
+            int out_col = block_col + col_fragment;
+            if (out_col + 1 < n) {
+                float2 value;
+                value.x = accum[i][0];
+                value.y = accum[i][1];
+                *reinterpret_cast<float2*>(&c[out_row * n + out_col]) = value;
+                continue;
+            }
+        }
+        for (j = 0; j < PYC_ADA_K64S2_THREAD_TILE_N; ++j) {
+            int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        ada_fp32_k64s2_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_k64s2_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_k64s2_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_K64S2_THREADS_X, PYC_ADA_K64S2_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_K64S2_BLOCK_N - 1) / PYC_ADA_K64S2_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_K64S2_BLOCK_M - 1) / PYC_ADA_K64S2_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_k64s2_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_k64s2_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_K64S2_BLOCK_M,
+           PYC_ADA_K64S2_BLOCK_N,
+           PYC_ADA_K64S2_BLOCK_K,
+           PYC_ADA_K64S2_THREADS_X,
+           PYC_ADA_K64S2_THREADS_Y,
+           PYC_ADA_K64S2_THREAD_TILE_M,
+           PYC_ADA_K64S2_THREAD_TILE_N,
+           PYC_ADA_K64S2_VEC);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/gemm_vec/kernel.cu

@@ -0,0 +1,374 @@
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PYC_ADA_VEC_BLOCK_M 128
+#define PYC_ADA_VEC_BLOCK_N 64
+#define PYC_ADA_VEC_BLOCK_K 8
+#define PYC_ADA_VEC_THREADS_X 16
+#define PYC_ADA_VEC_THREADS_Y 16
+#define PYC_ADA_VEC_THREAD_TILE_M 8
+#define PYC_ADA_VEC_THREAD_TILE_N 4
+#define PYC_ADA_VEC_WIDTH 4
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} ada_gemm_vec_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(float* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 17 + rows * 13 + cols * 7) % 31;
+        data[i] = ((float)pattern - 15.0f) * scale;
+    }
+}
+
+static void reference_gemm(const float* a, const float* b, float* c, int m, int n, int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += a[row * k + kk] * b[kk * n + col];
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static void load_a_vec(
+    const float* __restrict__ a,
+    float shared_a[PYC_ADA_VEC_BLOCK_M][PYC_ADA_VEC_BLOCK_K + 1],
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int vecs_per_row = PYC_ADA_VEC_BLOCK_K / PYC_ADA_VEC_WIDTH;
+    const int tile_row = lane_linear / vecs_per_row;
+    const int tile_col = (lane_linear % vecs_per_row) * PYC_ADA_VEC_WIDTH;
+    const int global_row = block_row + tile_row;
+    const int global_col = kk_base + tile_col;
+    int i;
+
+    if (global_row < m && global_col + (PYC_ADA_VEC_WIDTH - 1) < k) {
+        const float4 value = *reinterpret_cast<const float4*>(&a[global_row * k + global_col]);
+        shared_a[tile_row][tile_col + 0] = value.x;
+        shared_a[tile_row][tile_col + 1] = value.y;
+        shared_a[tile_row][tile_col + 2] = value.z;
+        shared_a[tile_row][tile_col + 3] = value.w;
+        return;
+    }
+
+    for (i = 0; i < PYC_ADA_VEC_WIDTH; ++i) {
+        float value = 0.0f;
+        if (global_row < m && global_col + i < k) {
+            value = a[global_row * k + global_col + i];
+        }
+        shared_a[tile_row][tile_col + i] = value;
+    }
+}
+
+__device__ static void load_b_vec(
+    const float* __restrict__ b,
+    float shared_b[PYC_ADA_VEC_BLOCK_K][PYC_ADA_VEC_BLOCK_N + 1],
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int vecs_per_row = PYC_ADA_VEC_BLOCK_N / PYC_ADA_VEC_WIDTH;
+    const int tile_row = lane_linear / vecs_per_row;
+    const int tile_col = (lane_linear % vecs_per_row) * PYC_ADA_VEC_WIDTH;
+    const int global_row = kk_base + tile_row;
+    const int global_col = block_col + tile_col;
+    int i;
+
+    if (global_row < k && global_col + (PYC_ADA_VEC_WIDTH - 1) < n) {
+        const float4 value = *reinterpret_cast<const float4*>(&b[global_row * n + global_col]);
+        shared_b[tile_row][tile_col + 0] = value.x;
+        shared_b[tile_row][tile_col + 1] = value.y;
+        shared_b[tile_row][tile_col + 2] = value.z;
+        shared_b[tile_row][tile_col + 3] = value.w;
+        return;
+    }
+
+    for (i = 0; i < PYC_ADA_VEC_WIDTH; ++i) {
+        float value = 0.0f;
+        if (global_row < k && global_col + i < n) {
+            value = b[global_row * n + global_col + i];
+        }
+        shared_b[tile_row][tile_col + i] = value;
+    }
+}
+
+__launch_bounds__(PYC_ADA_VEC_THREADS_X * PYC_ADA_VEC_THREADS_Y, 2)
+__global__ void ada_fp32_vec_gemm(
+    const float* __restrict__ a,
+    const float* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ float shared_a[PYC_ADA_VEC_BLOCK_M][PYC_ADA_VEC_BLOCK_K + 1];
+    __shared__ float shared_b[PYC_ADA_VEC_BLOCK_K][PYC_ADA_VEC_BLOCK_N + 1];
+
+    const int lane_linear = threadIdx.y * blockDim.x + threadIdx.x;
+    const int block_row = blockIdx.y * PYC_ADA_VEC_BLOCK_M;
+    const int block_col = blockIdx.x * PYC_ADA_VEC_BLOCK_N;
+    const int row_fragment = threadIdx.y * PYC_ADA_VEC_THREAD_TILE_M;
+    const int col_fragment = threadIdx.x * PYC_ADA_VEC_THREAD_TILE_N;
+    float accum[PYC_ADA_VEC_THREAD_TILE_M][PYC_ADA_VEC_THREAD_TILE_N];
+    int kk_base;
+    int i;
+    int j;
+
+    for (i = 0; i < PYC_ADA_VEC_THREAD_TILE_M; ++i) {
+        for (j = 0; j < PYC_ADA_VEC_THREAD_TILE_N; ++j) {
+            accum[i][j] = 0.0f;
+        }
+    }
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_ADA_VEC_BLOCK_K) {
+        load_a_vec(a, shared_a, lane_linear, block_row, kk_base, m, k);
+        if (lane_linear < (PYC_ADA_VEC_BLOCK_K * PYC_ADA_VEC_BLOCK_N) / PYC_ADA_VEC_WIDTH) {
+            load_b_vec(b, shared_b, lane_linear, block_col, kk_base, k, n);
+        }
+
+        __syncthreads();
+
+        #pragma unroll
+        for (i = 0; i < PYC_ADA_VEC_BLOCK_K; ++i) {
+            float a_frag[PYC_ADA_VEC_THREAD_TILE_M];
+            float b_frag[PYC_ADA_VEC_THREAD_TILE_N];
+            int ii;
+
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_VEC_THREAD_TILE_M; ++ii) {
+                a_frag[ii] = shared_a[row_fragment + ii][i];
+            }
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_VEC_THREAD_TILE_N; ++ii) {
+                b_frag[ii] = shared_b[i][col_fragment + ii];
+            }
+            #pragma unroll
+            for (ii = 0; ii < PYC_ADA_VEC_THREAD_TILE_M; ++ii) {
+                int jj;
+                #pragma unroll
+                for (jj = 0; jj < PYC_ADA_VEC_THREAD_TILE_N; ++jj) {
+                    accum[ii][jj] += a_frag[ii] * b_frag[jj];
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (i = 0; i < PYC_ADA_VEC_THREAD_TILE_M; ++i) {
+        const int out_row = block_row + row_fragment + i;
+        if (out_row >= m) {
+            continue;
+        }
+        for (j = 0; j < PYC_ADA_VEC_THREAD_TILE_N; ++j) {
+            const int out_col = block_col + col_fragment + j;
+            if (out_col < n) {
+                c[out_row * n + out_col] = accum[i][j];
+            }
+        }
+    }
+}
+
+static int configure_ada_kernel(void) {
+    cudaError_t status = cudaFuncSetAttribute(
+        ada_fp32_vec_gemm,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out) {
+    char* end = NULL;
+    long value;
+
+    if (!text || !out) {
+        return -1;
+    }
+
+    value = strtol(text, &end, 10);
+    if (*text == '\0' || !end || *end != '\0' || value <= 0 || value > 1 << 20) {
+        return -1;
+    }
+
+    *out = (int)value;
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, ada_gemm_vec_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    ada_gemm_vec_config cfg;
+    cudaDeviceProp props;
+    float* host_a = NULL;
+    float* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    float* dev_a = NULL;
+    float* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+    int device = 0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDevice(&device), "cudaGetDevice") != 0) return 1;
+    if (check_cuda(cudaGetDeviceProperties(&props, device), "cudaGetDeviceProperties") != 0) return 1;
+
+    printf("device=%s cc=%d.%d\n", props.name, props.major, props.minor);
+    if (!(props.major == 8 && props.minor == 9)) {
+        printf("note=prototype tuned for Ada (sm_89); running on a different architecture\n");
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(float);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(float);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (float*)malloc(a_bytes);
+    host_b = (float*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (configure_ada_kernel() != 0) return 1;
+
+    block = dim3(PYC_ADA_VEC_THREADS_X, PYC_ADA_VEC_THREADS_Y, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_ADA_VEC_BLOCK_N - 1) / PYC_ADA_VEC_BLOCK_N),
+        (unsigned int)((cfg.m + PYC_ADA_VEC_BLOCK_M - 1) / PYC_ADA_VEC_BLOCK_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        ada_fp32_vec_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        ada_fp32_vec_gemm<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("variant=ada_gemm_vec128x64\n");
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%dx%d thread_tile=%dx%d vector_width=%d\n",
+           PYC_ADA_VEC_BLOCK_M,
+           PYC_ADA_VEC_BLOCK_N,
+           PYC_ADA_VEC_BLOCK_K,
+           PYC_ADA_VEC_THREADS_X,
+           PYC_ADA_VEC_THREADS_Y,
+           PYC_ADA_VEC_THREAD_TILE_M,
+           PYC_ADA_VEC_THREAD_TILE_N,
+           PYC_ADA_VEC_WIDTH);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 1e-2 ? 0 : 1;
+}

kernels/prototypes/ada/tensor_core/kernel.cu

@@ -0,0 +1,327 @@
+#include <cuda_runtime.h>
+#include <mma.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(PYC_ADA_TENSOR_CORE_USE_BF16) && PYC_ADA_TENSOR_CORE_USE_BF16
+#include <cuda_bf16.h>
+typedef __nv_bfloat16 pyc_tc_scalar_t;
+#define PYC_TC_LANE_NAME "bf16"
+static __host__ __device__ inline pyc_tc_scalar_t pyc_tc_make_scalar(float value) {
+    return __float2bfloat16(value);
+}
+static __host__ __device__ inline float pyc_tc_scalar_to_float(pyc_tc_scalar_t value) {
+    return __bfloat162float(value);
+}
+#else
+#include <cuda_fp16.h>
+typedef half pyc_tc_scalar_t;
+#define PYC_TC_LANE_NAME "fp16"
+static __host__ __device__ inline pyc_tc_scalar_t pyc_tc_make_scalar(float value) {
+    return __float2half(value);
+}
+static __host__ __device__ inline float pyc_tc_scalar_to_float(pyc_tc_scalar_t value) {
+    return __half2float(value);
+}
+#endif
+
+namespace wmma = nvcuda::wmma;
+
+#define PYC_TC_CTA_M 32
+#define PYC_TC_CTA_N 64
+#define PYC_TC_CTA_K 16
+#define PYC_TC_WARPS_PER_BLOCK 8
+#define PYC_TC_THREADS_PER_BLOCK 256
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+} pyc_tc_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out_value) {
+    char* end = NULL;
+    long parsed;
+    if (!text || !out_value) {
+        return -1;
+    }
+    parsed = strtol(text, &end, 10);
+    if (end == text || *end != '\0' || parsed <= 0 || parsed > INT32_MAX) {
+        return -1;
+    }
+    *out_value = (int)parsed;
+    return 0;
+}
+
+static void fill_matrix(pyc_tc_scalar_t* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 19 + rows * 11 + cols * 7) % 29;
+        data[i] = pyc_tc_make_scalar(((float)pattern - 14.0f) * scale);
+    }
+}
+
+static void reference_gemm(
+    const pyc_tc_scalar_t* a,
+    const pyc_tc_scalar_t* b,
+    float* c,
+    int m,
+    int n,
+    int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += pyc_tc_scalar_to_float(a[row * k + kk]) * pyc_tc_scalar_to_float(b[kk * n + col]);
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__launch_bounds__(PYC_TC_THREADS_PER_BLOCK, 2)
+__global__ void pyc_tc_gemm_kernel(
+    const pyc_tc_scalar_t* __restrict__ a,
+    const pyc_tc_scalar_t* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ pyc_tc_scalar_t shared_a[PYC_TC_CTA_M][PYC_TC_CTA_K];
+    __shared__ pyc_tc_scalar_t shared_b[PYC_TC_CTA_N][PYC_TC_CTA_K];
+
+    const int warp_id = threadIdx.x / 32;
+    const int block_row = blockIdx.y * PYC_TC_CTA_M;
+    const int block_col = blockIdx.x * PYC_TC_CTA_N;
+    const int warp_row = (warp_id / 4) * 16;
+    const int warp_col = (warp_id % 4) * 16;
+    const int c_row = block_row + warp_row;
+    const int c_col = block_col + warp_col;
+
+    wmma::fragment<wmma::accumulator, 16, 16, 16, float> acc;
+    wmma::fill_fragment(acc, 0.0f);
+
+    if (warp_id >= PYC_TC_WARPS_PER_BLOCK) {
+        return;
+    }
+
+    for (int kk = 0; kk < k; kk += PYC_TC_CTA_K) {
+        int idx;
+
+        for (idx = threadIdx.x; idx < PYC_TC_CTA_M * PYC_TC_CTA_K; idx += blockDim.x) {
+            const int row = idx / PYC_TC_CTA_K;
+            const int col = idx % PYC_TC_CTA_K;
+            const int g_row = block_row + row;
+            const int g_col = kk + col;
+            if (g_row < m && g_col < k) {
+                shared_a[row][col] = a[g_row * k + g_col];
+            } else {
+                shared_a[row][col] = pyc_tc_make_scalar(0.0f);
+            }
+        }
+
+        for (idx = threadIdx.x; idx < PYC_TC_CTA_N * PYC_TC_CTA_K; idx += blockDim.x) {
+            const int row = idx / PYC_TC_CTA_K;
+            const int col = idx % PYC_TC_CTA_K;
+            const int g_row = kk + col;
+            const int g_col = block_col + row;
+            if (g_row < k && g_col < n) {
+                shared_b[row][col] = b[g_row * n + g_col];
+            } else {
+                shared_b[row][col] = pyc_tc_make_scalar(0.0f);
+            }
+        }
+
+        __syncthreads();
+
+        {
+            wmma::fragment<wmma::matrix_a, 16, 16, 16, pyc_tc_scalar_t, wmma::row_major> a_frag;
+            wmma::fragment<wmma::matrix_b, 16, 16, 16, pyc_tc_scalar_t, wmma::col_major> b_frag;
+            wmma::load_matrix_sync(a_frag, &shared_a[warp_row][0], PYC_TC_CTA_K);
+            wmma::load_matrix_sync(b_frag, &shared_b[warp_col][0], PYC_TC_CTA_K);
+            wmma::mma_sync(acc, a_frag, b_frag, acc);
+        }
+
+        __syncthreads();
+    }
+
+    if (c_row < m && c_col < n) {
+        wmma::store_matrix_sync(&c[c_row * n + c_col], acc, n, wmma::mem_row_major);
+    }
+}
+
+static int set_kernel_attributes(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        pyc_tc_gemm_kernel,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, pyc_tc_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 10;
+    cfg->iters = 50;
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    pyc_tc_config cfg;
+    cudaDeviceProp props;
+    pyc_tc_scalar_t* host_a = NULL;
+    pyc_tc_scalar_t* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    pyc_tc_scalar_t* dev_a = NULL;
+    pyc_tc_scalar_t* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    int iter;
+    double max_abs_diff = 0.0;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters]\n", argv[0]);
+        return 2;
+    }
+
+    if ((cfg.m % PYC_TC_CTA_M) != 0 || (cfg.n % PYC_TC_CTA_N) != 0 || (cfg.k % PYC_TC_CTA_K) != 0) {
+        fprintf(stderr, "Tensor Core lane requires %dx%dx%d-aligned shapes\n", PYC_TC_CTA_M, PYC_TC_CTA_N, PYC_TC_CTA_K);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDeviceProperties(&props, 0), "cudaGetDeviceProperties") != 0) {
+        return 1;
+    }
+    if (props.major < 8 || (props.major == 8 && props.minor < 9)) {
+        fprintf(stderr, "Ada Tensor Core prototype requires sm_89-class hardware\n");
+        return 1;
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(pyc_tc_scalar_t);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(pyc_tc_scalar_t);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (pyc_tc_scalar_t*)malloc(a_bytes);
+    host_b = (pyc_tc_scalar_t*)malloc(b_bytes);
+    host_c = (float*)malloc(c_bytes);
+    ref_c = (float*)malloc(c_bytes);
+    if (!host_a || !host_b || !host_c || !ref_c) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (set_kernel_attributes() != 0) return 1;
+
+    block = dim3(PYC_TC_THREADS_PER_BLOCK, 1, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_TC_CTA_N - 1) / PYC_TC_CTA_N),
+        (unsigned int)((cfg.m + PYC_TC_CTA_M - 1) / PYC_TC_CTA_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        pyc_tc_gemm_kernel<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        pyc_tc_gemm_kernel<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+        double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+        if (diff > max_abs_diff) {
+            max_abs_diff = diff;
+        }
+    }
+
+    printf("lane=%s\n", PYC_TC_LANE_NAME);
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("tile=%dx%dx%d threads=%d\n", PYC_TC_CTA_M, PYC_TC_CTA_N, PYC_TC_CTA_K, PYC_TC_THREADS_PER_BLOCK);
+    printf("best_ms=%.3f\n", best_ms);
+    printf("max_abs_diff=%.6f\n", max_abs_diff);
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return max_abs_diff <= 0.2 ? 0 : 1;
+}

kernels/prototypes/baseline/matmul/kernel.cu

@@ -0,0 +1,30 @@
+// /kernel/matrix_mult.cu
+#include <cuda_runtime.h>
+
+__global__ void matrix_mult_kernel(float* a, float* b, float* c, int m, int n, int k) {
+    int row = blockIdx.y * blockDim.y + threadIdx.y;
+    int col = blockIdx.x * blockDim.x + threadIdx.x;
+    if (row < m && col < n) {
+        float sum = 0.0f;
+        for (int i = 0; i < k; i++) {
+            sum += a[row * k + i] * b[i * n + col];
+        }
+        c[row * n + col] = sum;
+    }
+}
+
+void matrix_multiply(float* a, float* b, float* c, int m, int n, int k) {
+    float *d_a, *d_b, *d_c;
+    cudaMalloc(&d_a, m * k * sizeof(float));
+    cudaMalloc(&d_b, k * n * sizeof(float));
+    cudaMalloc(&d_c, m * n * sizeof(float));
+    cudaMemcpy(d_a, a, m * k * sizeof(float), cudaMemcpyHostToDevice);
+    cudaMemcpy(d_b, b, k * n * sizeof(float), cudaMemcpyHostToDevice);
+
+    dim3 threads(16, 16);
+    dim3 blocks((n + threads.x - 1) / threads.x, (m + threads.y - 1) / threads.y);
+    matrix_mult_kernel<<<blocks, threads>>>(d_a, d_b, d_c, m, n, k);
+
+    cudaMemcpy(c, d_c, m * n * sizeof(float), cudaMemcpyDeviceToHost);
+    cudaFree(d_a); cudaFree(d_b); cudaFree(d_c);
+}

kernels/prototypes/experimental/tokenizer_matmul/kernel.cu

@@ -0,0 +1,248 @@
+#include <cuda_runtime.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#define MAX_TOKENS 1024
+
+// Enhanced token types
+typedef enum {
+    TOKEN_IDENTIFIER = 0,
+    TOKEN_NUMBER = 1,
+    TOKEN_OPERATOR = 2,
+    TOKEN_KEYWORD = 3,
+    TOKEN_STRING = 4,
+    TOKEN_COMMENT = 5,
+    TOKEN_PREPROCESSOR = 6,
+    TOKEN_PUNCTUATION = 7
+} TokenType;
+
+// Add token metadata
+typedef struct {
+    TokenType type;
+    int start_pos;
+    int end_pos;
+    int length;
+    int line;
+    int column;
+    char lexeme[256];
+    unsigned int hash;
+} EnhancedTokenGPU;
+
+typedef struct {
+    int type; // 0: identifier, 1: number, 2: operator
+    int start_pos;
+    int end_pos;
+    int length;
+} TokenGPU;
+
+// Add shared memory optimization
+__shared__ char shared_input[1024];
+__shared__ int shared_token_count;
+
+// Enhanced tokenization kernel with better pattern matching
+__global__ void enhanced_tokenize_kernel(const char* input, size_t input_length,
+                                       EnhancedTokenGPU* tokens, int* token_count,
+                                       bool enable_comments, bool enable_preprocessing) {
+    int idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx >= input_length) return;
+
+    // Load chunk into shared memory
+    int local_idx = threadIdx.x;
+    if (local_idx < 1024 && idx < input_length) {
+        shared_input[local_idx] = input[idx];
+    }
+    __syncthreads();
+
+    // Enhanced token detection with more patterns
+    if (idx > 0 && (isalnum(shared_input[local_idx-1]) && isalnum(shared_input[local_idx]))) return;
+
+    int tcount = atomicAdd(token_count, 0);
+    if (tcount >= MAX_TOKENS) return;
+
+    EnhancedTokenGPU token;
+    token.start_pos = idx;
+    token.hash = 0;
+
+    // Calculate line and column
+    int line = 1, column = 1;
+    for (int i = 0; i < idx; i++) {
+        if (input[i] == '\n') {
+            line++;
+            column = 1;
+        } else {
+            column++;
+        }
+    }
+    token.line = line;
+    token.column = column;
+
+    // Enhanced pattern matching
+    if (isalpha(shared_input[local_idx]) || shared_input[local_idx] == '_') {
+        // Handle identifiers and keywords
+        int end = local_idx;
+        while (end < 1024 && (isalnum(shared_input[end]) || shared_input[end] == '_')) {
+            token.hash = token.hash * 31 + shared_input[end];
+            end++;
+        }
+        token.type = TOKEN_IDENTIFIER;
+        token.end_pos = idx + (end - local_idx) - 1;
+        token.length = end - local_idx;
+    }
+    // ... Add more token pattern matching ...
+
+    // Store token if valid
+    if (token.length > 0) {
+        int new_count = atomicAdd(token_count, 1);
+        if (new_count < MAX_TOKENS) {
+            tokens[new_count] = token;
+        }
+    }
+}
+
+__global__ void tokenize_kernel(const char* input, size_t input_length, TokenGPU* tokens, int* token_count) {
+    int idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx >= input_length) return;
+
+    // Skip if not at token boundary
+    if (idx > 0 && (isalnum(input[idx-1]) && isalnum(input[idx]))) return;
+
+    int tcount = *token_count;
+    if (tcount >= MAX_TOKENS) return;
+
+    if (isalpha(input[idx])) {
+        int end = idx;
+        while (end < input_length && isalnum(input[end])) end++;
+        int new_count = atomicAdd(token_count, 1);
+        if (new_count < MAX_TOKENS) {
+            tokens[new_count].type = 0;
+            tokens[new_count].start_pos = idx;
+            tokens[new_count].end_pos = end - 1;
+            tokens[new_count].length = end - idx;
+        }
+    } else if (isdigit(input[idx])) {
+        int end = idx;
+        while (end < input_length && isdigit(input[end])) end++;
+        int new_count = atomicAdd(token_count, 1);
+        if (new_count < MAX_TOKENS) {
+            tokens[new_count].type = 1;
+            tokens[new_count].start_pos = idx;
+            tokens[new_count].end_pos = end - 1;
+            tokens[new_count].length = end - idx;
+        }
+    } else if (input[idx] == '+' || input[idx] == '-' || input[idx] == '*' || input[idx] == '/') {
+        int new_count = atomicAdd(token_count, 1);
+        if (new_count < MAX_TOKENS) {
+            tokens[new_count].type = 2;
+            tokens[new_count].start_pos = idx;
+            tokens[new_count].end_pos = idx;
+            tokens[new_count].length = 1;
+        }
+    }
+}
+
+__global__ void matrix_mult_kernel(float* a, float* b, float* c, int m, int n, int k) {
+    int row = blockIdx.y * blockDim.y + threadIdx.y;
+    int col = blockIdx.x * blockDim.x + threadIdx.x;
+    if (row < m && col < n) {
+        float sum = 0.0f;
+        for (int i = 0; i < k; i++) {
+            sum += a[row * k + i] * b[i * n + col];
+        }
+        c[row * n + col] = sum;
+    }
+}
+
+// Add parallel matrix operations
+__global__ void enhanced_matrix_mult_kernel(float* a, float* b, float* c,
+                                          int m, int n, int k,
+                                          bool use_shared_memory) {
+    // ... existing matrix multiplication code ...
+
+    // Add shared memory optimization
+    __shared__ float shared_a[16][16];
+    __shared__ float shared_b[16][16];
+
+    // ... implement block matrix multiplication ...
+}
+
+// Add new CUDA utilities
+void initialize_cuda_context(void) {
+    cudaFree(0); // Force context initialization
+}
+
+void optimize_kernel_launch(dim3* blocks, dim3* threads, size_t shared_memory_size) {
+    int device;
+    cudaGetDevice(&device);
+    cudaDeviceProp props;
+    cudaGetDeviceProperties(&props, device);
+
+    // Optimize launch configuration based on device properties
+    // ... implementation ...
+}
+
+void cuda_tokenize(const char* input, TokenGPU* tokens, int* token_count) {
+    size_t input_length = strlen(input);
+    char* d_input;
+    TokenGPU* d_tokens;
+    int* d_token_count;
+
+    cudaMalloc(&d_input, input_length + 1);
+    cudaMalloc(&d_tokens, MAX_TOKENS * sizeof(TokenGPU));
+    cudaMalloc(&d_token_count, sizeof(int));
+    cudaMemcpy(d_input, input, input_length + 1, cudaMemcpyHostToDevice);
+    cudaMemset(d_token_count, 0, sizeof(int));
+
+    int threads = 256;
+    int blocks = (input_length + threads - 1) / threads;
+    tokenize_kernel<<<blocks, threads>>>(d_input, input_length, d_tokens, d_token_count);
+
+    cudaMemcpy(token_count, d_token_count, sizeof(int), cudaMemcpyDeviceToHost);
+    cudaMemcpy(tokens, d_tokens, *token_count * sizeof(TokenGPU), cudaMemcpyDeviceToHost);
+
+    cudaFree(d_input);
+    cudaFree(d_tokens);
+    cudaFree(d_token_count);
+}
+
+void cuda_matrix_mult(float* a, float* b, float* c, int m, int n, int k) {
+    float *d_a, *d_b, *d_c;
+    cudaMalloc(&d_a, m * k * sizeof(float));
+    cudaMalloc(&d_b, k * n * sizeof(float));
+    cudaMalloc(&d_c, m * n * sizeof(float));
+    cudaMemcpy(d_a, a, m * k * sizeof(float), cudaMemcpyHostToDevice);
+    cudaMemcpy(d_b, b, k * n * sizeof(float), cudaMemcpyHostToDevice);
+
+    dim3 threads(16, 16);
+    dim3 blocks((n + threads.x - 1) / threads.x, (m + threads.y - 1) / threads.y);
+    matrix_mult_kernel<<<blocks, threads>>>(d_a, d_b, d_c, m, n, k);
+
+    cudaMemcpy(c, d_c, m * n * sizeof(float), cudaMemcpyDeviceToHost);
+    cudaFree(d_a); cudaFree(d_b); cudaFree(d_c);
+}
+void print_tokens(TokenGPU* tokens, int token_count) {
+    for (int i = 0; i < token_count; i++) {
+        printf("Token %d: Type %d, Start %d, End %d, Length %d\n",
+               i, tokens[i].type, tokens[i].start_pos, tokens[i].end_pos, tokens[i].length);
+    }
+}
+int main() {
+    const char* input = "int a = 5 + 3;";
+    TokenGPU tokens[MAX_TOKENS];
+    int token_count;
+
+    cuda_tokenize(input, tokens, &token_count);
+    print_tokens(tokens, token_count);
+
+    float a[6] = {1, 2, 3, 4, 5, 6};
+    float b[6] = {7, 8, 9, 10, 11, 12};
+    float c[4] = {0};
+
+    cuda_matrix_mult(a, b, c, 2, 3, 2);
+    for (int i = 0; i < 4; i++) {
+        printf("%f ", c[i]);
+    }
+    printf("\n");
+
+    return 0;
+}
+// Compile with nvcc -o kernel kernel.cu

kernels/prototypes/hopper/cublaslt_bf16/kernel.cu

@@ -0,0 +1,331 @@
+#include <cublasLt.h>
+#include <cuda_bf16.h>
+#include <cuda_runtime.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+    int skip_reference;
+} pyc_hopper_cublaslt_bf16_config;
+
+static int parse_int_arg(const char* text, int* out_value) {
+    char* end = NULL;
+    long parsed;
+    if (!text || !out_value) {
+        return -1;
+    }
+    parsed = strtol(text, &end, 10);
+    if (end == text || *end != '\0' || parsed < 0 || parsed > INT32_MAX) {
+        return -1;
+    }
+    *out_value = (int)parsed;
+    return 0;
+}
+
+static int env_flag(const char* name, int default_value) {
+    const char* raw = getenv(name);
+    if (!raw || raw[0] == '\0') {
+        return default_value;
+    }
+    if (
+        strcmp(raw, "1") == 0 || strcmp(raw, "true") == 0 || strcmp(raw, "TRUE") == 0
+        || strcmp(raw, "yes") == 0 || strcmp(raw, "on") == 0) {
+        return 1;
+    }
+    if (
+        strcmp(raw, "0") == 0 || strcmp(raw, "false") == 0 || strcmp(raw, "FALSE") == 0
+        || strcmp(raw, "no") == 0 || strcmp(raw, "off") == 0) {
+        return 0;
+    }
+    return default_value;
+}
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static int check_cublas(cublasStatus_t status, const char* what) {
+    if (status != CUBLAS_STATUS_SUCCESS) {
+        fprintf(stderr, "%s failed: cublas status %d\n", what, (int)status);
+        return -1;
+    }
+    return 0;
+}
+
+static void fill_matrix(__nv_bfloat16* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 23 + rows * 13 + cols * 5) % 31;
+        data[i] = __float2bfloat16(((float)pattern - 15.0f) * scale);
+    }
+}
+
+static void reference_gemm(
+    const __nv_bfloat16* a,
+    const __nv_bfloat16* b,
+    __nv_bfloat16* d,
+    int m,
+    int n,
+    int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += __bfloat162float(a[row * k + kk]) * __bfloat162float(b[kk * n + col]);
+            }
+            d[row * n + col] = __float2bfloat16(acc);
+        }
+    }
+}
+
+static int parse_config(int argc, char** argv, pyc_hopper_cublaslt_bf16_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 4096;
+    cfg->n = 4096;
+    cfg->k = 4096;
+    cfg->warmup = 3;
+    cfg->iters = 30;
+    cfg->skip_reference = env_flag("PYC_HOPPER_CUBLASLT_SKIP_REFERENCE", 1);
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+    if (argc > 6 && parse_int_arg(argv[6], &cfg->skip_reference) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    pyc_hopper_cublaslt_bf16_config cfg;
+    struct cudaDeviceProp props;
+    cublasLtHandle_t lt_handle = NULL;
+    cublasLtMatmulDesc_t op_desc = NULL;
+    cublasLtMatrixLayout_t a_layout = NULL;
+    cublasLtMatrixLayout_t b_layout = NULL;
+    cublasLtMatrixLayout_t c_layout = NULL;
+    cublasLtMatmulPreference_t pref = NULL;
+    cublasLtMatmulHeuristicResult_t heuristic;
+    int returned_results = 0;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    cudaStream_t stream = NULL;
+    __nv_bfloat16* host_a = NULL;
+    __nv_bfloat16* host_b = NULL;
+    __nv_bfloat16* host_d = NULL;
+    __nv_bfloat16* ref_d = NULL;
+    __nv_bfloat16* dev_a = NULL;
+    __nv_bfloat16* dev_b = NULL;
+    __nv_bfloat16* dev_d = NULL;
+    void* workspace = NULL;
+    size_t workspace_bytes = 64u * 1024u * 1024u;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t d_bytes;
+    float alpha = 1.0f;
+    float beta = 0.0f;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    double max_abs_diff = 0.0;
+    int iter;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters] [skip_reference]\n", argv[0]);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDeviceProperties(&props, 0), "cudaGetDeviceProperties") != 0) {
+        return 1;
+    }
+    if (props.major < 9) {
+        fprintf(stderr, "Hopper cuBLASLt BF16 prototype requires sm_90-class hardware\n");
+        return 1;
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(__nv_bfloat16);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(__nv_bfloat16);
+    d_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(__nv_bfloat16);
+
+    host_a = (__nv_bfloat16*)malloc(a_bytes);
+    host_b = (__nv_bfloat16*)malloc(b_bytes);
+    if (!host_a || !host_b) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+    if (!cfg.skip_reference) {
+        host_d = (__nv_bfloat16*)malloc(d_bytes);
+        ref_d = (__nv_bfloat16*)malloc(d_bytes);
+        if (!host_d || !ref_d) {
+            fprintf(stderr, "host validation allocation failed\n");
+            return 1;
+        }
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    if (!cfg.skip_reference) {
+        reference_gemm(host_a, host_b, ref_d, cfg.m, cfg.n, cfg.k);
+    }
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_d, d_bytes), "cudaMalloc(d)") != 0) return 1;
+    if (check_cuda(cudaMalloc(&workspace, workspace_bytes), "cudaMalloc(workspace)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+    if (check_cuda(cudaMemset(dev_d, 0, d_bytes), "cudaMemset(d)") != 0) return 1;
+
+    if (check_cuda(cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking), "cudaStreamCreateWithFlags") != 0) return 1;
+    if (check_cublas(cublasLtCreate(&lt_handle), "cublasLtCreate") != 0) return 1;
+
+    if (check_cublas(cublasLtMatmulDescCreate(&op_desc, CUBLAS_COMPUTE_32F, CUDA_R_32F), "cublasLtMatmulDescCreate") != 0) return 1;
+    {
+        cublasOperation_t transa = CUBLAS_OP_N;
+        cublasOperation_t transb = CUBLAS_OP_N;
+        if (check_cublas(cublasLtMatmulDescSetAttribute(op_desc, CUBLASLT_MATMUL_DESC_TRANSA, &transa, sizeof(transa)), "cublasLtMatmulDescSetAttribute(TRANSA)") != 0) return 1;
+        if (check_cublas(cublasLtMatmulDescSetAttribute(op_desc, CUBLASLT_MATMUL_DESC_TRANSB, &transb, sizeof(transb)), "cublasLtMatmulDescSetAttribute(TRANSB)") != 0) return 1;
+    }
+
+    if (check_cublas(cublasLtMatrixLayoutCreate(&a_layout, CUDA_R_16BF, cfg.m, cfg.k, cfg.k), "cublasLtMatrixLayoutCreate(A)") != 0) return 1;
+    if (check_cublas(cublasLtMatrixLayoutCreate(&b_layout, CUDA_R_16BF, cfg.k, cfg.n, cfg.n), "cublasLtMatrixLayoutCreate(B)") != 0) return 1;
+    if (check_cublas(cublasLtMatrixLayoutCreate(&c_layout, CUDA_R_16BF, cfg.m, cfg.n, cfg.n), "cublasLtMatrixLayoutCreate(D)") != 0) return 1;
+    {
+        cublasLtOrder_t order = CUBLASLT_ORDER_ROW;
+        if (check_cublas(cublasLtMatrixLayoutSetAttribute(a_layout, CUBLASLT_MATRIX_LAYOUT_ORDER, &order, sizeof(order)), "cublasLtMatrixLayoutSetAttribute(A order)") != 0) return 1;
+        if (check_cublas(cublasLtMatrixLayoutSetAttribute(b_layout, CUBLASLT_MATRIX_LAYOUT_ORDER, &order, sizeof(order)), "cublasLtMatrixLayoutSetAttribute(B order)") != 0) return 1;
+        if (check_cublas(cublasLtMatrixLayoutSetAttribute(c_layout, CUBLASLT_MATRIX_LAYOUT_ORDER, &order, sizeof(order)), "cublasLtMatrixLayoutSetAttribute(D order)") != 0) return 1;
+    }
+
+    if (check_cublas(cublasLtMatmulPreferenceCreate(&pref), "cublasLtMatmulPreferenceCreate") != 0) return 1;
+    if (check_cublas(cublasLtMatmulPreferenceSetAttribute(pref, CUBLASLT_MATMUL_PREF_MAX_WORKSPACE_BYTES, &workspace_bytes, sizeof(workspace_bytes)), "cublasLtMatmulPreferenceSetAttribute") != 0) return 1;
+    if (check_cublas(cublasLtMatmulAlgoGetHeuristic(lt_handle, op_desc, a_layout, b_layout, c_layout, c_layout, pref, 1, &heuristic, &returned_results), "cublasLtMatmulAlgoGetHeuristic") != 0) return 1;
+    if (returned_results <= 0) {
+        fprintf(stderr, "cublasLtMatmulAlgoGetHeuristic returned no algorithms\n");
+        return 1;
+    }
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        if (check_cublas(
+                cublasLtMatmul(
+                    lt_handle,
+                    op_desc,
+                    &alpha,
+                    dev_a,
+                    a_layout,
+                    dev_b,
+                    b_layout,
+                    &beta,
+                    dev_d,
+                    c_layout,
+                    dev_d,
+                    c_layout,
+                    &heuristic.algo,
+                    workspace,
+                    workspace_bytes,
+                    stream),
+                "cublasLtMatmul(warmup)")
+            != 0) return 1;
+    }
+    if (check_cuda(cudaStreamSynchronize(stream), "cudaStreamSynchronize(warmup)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start, stream), "cudaEventRecord(start)") != 0) return 1;
+        if (check_cublas(
+                cublasLtMatmul(
+                    lt_handle,
+                    op_desc,
+                    &alpha,
+                    dev_a,
+                    a_layout,
+                    dev_b,
+                    b_layout,
+                    &beta,
+                    dev_d,
+                    c_layout,
+                    dev_d,
+                    c_layout,
+                    &heuristic.algo,
+                    workspace,
+                    workspace_bytes,
+                    stream),
+                "cublasLtMatmul(bench)")
+            != 0) return 1;
+        if (check_cuda(cudaEventRecord(stop, stream), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (!cfg.skip_reference) {
+        int idx;
+        if (check_cuda(cudaMemcpy(host_d, dev_d, d_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(d)") != 0) return 1;
+        for (idx = 0; idx < cfg.m * cfg.n; ++idx) {
+            double diff = fabs((double)__bfloat162float(host_d[idx]) - (double)__bfloat162float(ref_d[idx]));
+            if (diff > max_abs_diff) {
+                max_abs_diff = diff;
+            }
+        }
+    }
+
+    printf("kernel=hopper_cublaslt_bf16\n");
+    printf("arch=sm%d%d\n", props.major, props.minor);
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf("workspace_bytes=%zu\n", workspace_bytes);
+    printf("heuristic_workspace_bytes=%zu\n", heuristic.workspaceSize);
+    printf("skip_reference=%d\n", cfg.skip_reference);
+    printf("best_ms=%.3f\n", best_ms);
+    if (!cfg.skip_reference) {
+        printf("max_abs_diff=%.6f\n", max_abs_diff);
+    }
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+        printf("tflops=%.3f\n", gflops / 1000.0);
+    }
+
+    if (start) cudaEventDestroy(start);
+    if (stop) cudaEventDestroy(stop);
+    if (stream) cudaStreamDestroy(stream);
+    if (pref) cublasLtMatmulPreferenceDestroy(pref);
+    if (c_layout) cublasLtMatrixLayoutDestroy(c_layout);
+    if (b_layout) cublasLtMatrixLayoutDestroy(b_layout);
+    if (a_layout) cublasLtMatrixLayoutDestroy(a_layout);
+    if (op_desc) cublasLtMatmulDescDestroy(op_desc);
+    if (lt_handle) cublasLtDestroy(lt_handle);
+    if (workspace) cudaFree(workspace);
+    if (dev_d) cudaFree(dev_d);
+    if (dev_b) cudaFree(dev_b);
+    if (dev_a) cudaFree(dev_a);
+    free(ref_d);
+    free(host_d);
+    free(host_b);
+    free(host_a);
+    return (cfg.skip_reference || max_abs_diff <= 0.25) ? 0 : 1;
+}

kernels/prototypes/hopper/tensor_core/kernel.cu

@@ -0,0 +1,450 @@
+#include <cuda_runtime.h>
+#include <mma.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(PYC_HOPPER_TENSOR_CORE_USE_BF16) && PYC_HOPPER_TENSOR_CORE_USE_BF16
+#include <cuda_bf16.h>
+typedef __nv_bfloat16 pyc_hopper_tc_scalar_t;
+#define PYC_HOPPER_TC_LANE_NAME "bf16"
+static __host__ __device__ inline pyc_hopper_tc_scalar_t pyc_hopper_tc_make_scalar(float value) {
+    return __float2bfloat16(value);
+}
+static __host__ __device__ inline float pyc_hopper_tc_scalar_to_float(pyc_hopper_tc_scalar_t value) {
+    return __bfloat162float(value);
+}
+#else
+#include <cuda_fp16.h>
+typedef half pyc_hopper_tc_scalar_t;
+#define PYC_HOPPER_TC_LANE_NAME "fp16"
+static __host__ __device__ inline pyc_hopper_tc_scalar_t pyc_hopper_tc_make_scalar(float value) {
+    return __float2half(value);
+}
+static __host__ __device__ inline float pyc_hopper_tc_scalar_to_float(pyc_hopper_tc_scalar_t value) {
+    return __half2float(value);
+}
+#endif
+
+namespace wmma = nvcuda::wmma;
+
+#ifndef PYC_HOPPER_TC_MMA_TILE_M
+#define PYC_HOPPER_TC_MMA_TILE_M 16
+#endif
+
+#ifndef PYC_HOPPER_TC_MMA_TILE_N
+#define PYC_HOPPER_TC_MMA_TILE_N 16
+#endif
+
+#ifndef PYC_HOPPER_TC_MMA_TILE_K
+#define PYC_HOPPER_TC_MMA_TILE_K 16
+#endif
+
+#ifndef PYC_HOPPER_TC_WARP_ROW_TILES
+#define PYC_HOPPER_TC_WARP_ROW_TILES 1
+#endif
+
+#ifndef PYC_HOPPER_TC_WARP_COL_TILES
+#define PYC_HOPPER_TC_WARP_COL_TILES 1
+#endif
+
+#ifndef PYC_HOPPER_TC_WARP_ROW_GROUPS
+#define PYC_HOPPER_TC_WARP_ROW_GROUPS 4
+#endif
+
+#ifndef PYC_HOPPER_TC_WARP_COL_GROUPS
+#define PYC_HOPPER_TC_WARP_COL_GROUPS 4
+#endif
+
+#ifndef PYC_HOPPER_TC_TILE_K
+#define PYC_HOPPER_TC_TILE_K 16
+#endif
+
+#ifndef PYC_HOPPER_TC_SHARED_PAD_A
+#define PYC_HOPPER_TC_SHARED_PAD_A 0
+#endif
+
+#ifndef PYC_HOPPER_TC_SHARED_PAD_B
+#define PYC_HOPPER_TC_SHARED_PAD_B 0
+#endif
+
+#define PYC_HOPPER_TC_WARP_TILE_M (PYC_HOPPER_TC_MMA_TILE_M * PYC_HOPPER_TC_WARP_ROW_TILES)
+#define PYC_HOPPER_TC_WARP_TILE_N (PYC_HOPPER_TC_MMA_TILE_N * PYC_HOPPER_TC_WARP_COL_TILES)
+#define PYC_HOPPER_TC_TILE_M (PYC_HOPPER_TC_WARP_TILE_M * PYC_HOPPER_TC_WARP_ROW_GROUPS)
+#define PYC_HOPPER_TC_TILE_N (PYC_HOPPER_TC_WARP_TILE_N * PYC_HOPPER_TC_WARP_COL_GROUPS)
+#define PYC_HOPPER_TC_WARPS_PER_BLOCK (PYC_HOPPER_TC_WARP_ROW_GROUPS * PYC_HOPPER_TC_WARP_COL_GROUPS)
+#define PYC_HOPPER_TC_THREADS_PER_BLOCK (PYC_HOPPER_TC_WARPS_PER_BLOCK * 32)
+#define PYC_HOPPER_TC_SHARED_STRIDE_A (PYC_HOPPER_TC_TILE_K + PYC_HOPPER_TC_SHARED_PAD_A)
+#define PYC_HOPPER_TC_SHARED_STRIDE_B (PYC_HOPPER_TC_TILE_K + PYC_HOPPER_TC_SHARED_PAD_B)
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+    int skip_reference;
+} pyc_hopper_tc_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out_value) {
+    char* end = NULL;
+    long parsed;
+    if (!text || !out_value) {
+        return -1;
+    }
+    parsed = strtol(text, &end, 10);
+    if (end == text || *end != '\0' || parsed < 0 || parsed > INT32_MAX) {
+        return -1;
+    }
+    *out_value = (int)parsed;
+    return 0;
+}
+
+static int env_flag(const char* name, int default_value) {
+    const char* raw = getenv(name);
+    if (!raw || raw[0] == '\0') {
+        return default_value;
+    }
+    if (
+        strcmp(raw, "1") == 0 || strcmp(raw, "true") == 0 || strcmp(raw, "TRUE") == 0
+        || strcmp(raw, "yes") == 0 || strcmp(raw, "on") == 0) {
+        return 1;
+    }
+    if (
+        strcmp(raw, "0") == 0 || strcmp(raw, "false") == 0 || strcmp(raw, "FALSE") == 0
+        || strcmp(raw, "no") == 0 || strcmp(raw, "off") == 0) {
+        return 0;
+    }
+    return default_value;
+}
+
+static void fill_matrix(pyc_hopper_tc_scalar_t* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 23 + rows * 13 + cols * 5) % 31;
+        data[i] = pyc_hopper_tc_make_scalar(((float)pattern - 15.0f) * scale);
+    }
+}
+
+static void reference_gemm(
+    const pyc_hopper_tc_scalar_t* a,
+    const pyc_hopper_tc_scalar_t* b,
+    float* c,
+    int m,
+    int n,
+    int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += pyc_hopper_tc_scalar_to_float(a[row * k + kk]) * pyc_hopper_tc_scalar_to_float(b[kk * n + col]);
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__launch_bounds__(PYC_HOPPER_TC_THREADS_PER_BLOCK, 1)
+__global__ void pyc_hopper_tc_gemm_kernel(
+    const pyc_hopper_tc_scalar_t* __restrict__ a,
+    const pyc_hopper_tc_scalar_t* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    __shared__ __align__(16) pyc_hopper_tc_scalar_t shared_a[PYC_HOPPER_TC_TILE_M][PYC_HOPPER_TC_SHARED_STRIDE_A];
+    __shared__ __align__(16) pyc_hopper_tc_scalar_t shared_b[PYC_HOPPER_TC_TILE_N][PYC_HOPPER_TC_SHARED_STRIDE_B];
+
+    const int warp_id = threadIdx.x / 32;
+    const int block_row = blockIdx.y * PYC_HOPPER_TC_TILE_M;
+    const int block_col = blockIdx.x * PYC_HOPPER_TC_TILE_N;
+    const int warp_row_group = warp_id / PYC_HOPPER_TC_WARP_COL_GROUPS;
+    const int warp_col_group = warp_id % PYC_HOPPER_TC_WARP_COL_GROUPS;
+    const int warp_row = warp_row_group * PYC_HOPPER_TC_WARP_TILE_M;
+    const int warp_col = warp_col_group * PYC_HOPPER_TC_WARP_TILE_N;
+
+    wmma::fragment<wmma::accumulator, 16, 16, 16, float> acc[PYC_HOPPER_TC_WARP_ROW_TILES][PYC_HOPPER_TC_WARP_COL_TILES];
+
+    if (warp_id >= PYC_HOPPER_TC_WARPS_PER_BLOCK) {
+        return;
+    }
+
+    for (int row_tile = 0; row_tile < PYC_HOPPER_TC_WARP_ROW_TILES; ++row_tile) {
+        for (int col_tile = 0; col_tile < PYC_HOPPER_TC_WARP_COL_TILES; ++col_tile) {
+            wmma::fill_fragment(acc[row_tile][col_tile], 0.0f);
+        }
+    }
+
+    for (int kk = 0; kk < k; kk += PYC_HOPPER_TC_TILE_K) {
+        int idx;
+
+        for (idx = threadIdx.x; idx < PYC_HOPPER_TC_TILE_M * PYC_HOPPER_TC_TILE_K; idx += blockDim.x) {
+            const int row = idx / PYC_HOPPER_TC_TILE_K;
+            const int col = idx % PYC_HOPPER_TC_TILE_K;
+            const int g_row = block_row + row;
+            const int g_col = kk + col;
+            if (g_row < m && g_col < k) {
+                shared_a[row][col] = a[g_row * k + g_col];
+            } else {
+                shared_a[row][col] = pyc_hopper_tc_make_scalar(0.0f);
+            }
+        }
+
+        for (idx = threadIdx.x; idx < PYC_HOPPER_TC_TILE_N * PYC_HOPPER_TC_TILE_K; idx += blockDim.x) {
+            const int row = idx / PYC_HOPPER_TC_TILE_K;
+            const int col = idx % PYC_HOPPER_TC_TILE_K;
+            const int g_row = kk + col;
+            const int g_col = block_col + row;
+            if (g_row < k && g_col < n) {
+                shared_b[row][col] = b[g_row * n + g_col];
+            } else {
+                shared_b[row][col] = pyc_hopper_tc_make_scalar(0.0f);
+            }
+        }
+
+        __syncthreads();
+
+        for (int k_frag = 0; k_frag < PYC_HOPPER_TC_TILE_K; k_frag += PYC_HOPPER_TC_MMA_TILE_K) {
+            wmma::fragment<wmma::matrix_a, 16, 16, 16, pyc_hopper_tc_scalar_t, wmma::row_major> a_frag[PYC_HOPPER_TC_WARP_ROW_TILES];
+            wmma::fragment<wmma::matrix_b, 16, 16, 16, pyc_hopper_tc_scalar_t, wmma::col_major> b_frag[PYC_HOPPER_TC_WARP_COL_TILES];
+
+            for (int row_tile = 0; row_tile < PYC_HOPPER_TC_WARP_ROW_TILES; ++row_tile) {
+                const int a_row = warp_row + row_tile * PYC_HOPPER_TC_MMA_TILE_M;
+                wmma::load_matrix_sync(a_frag[row_tile], &shared_a[a_row][k_frag], PYC_HOPPER_TC_SHARED_STRIDE_A);
+            }
+
+            for (int col_tile = 0; col_tile < PYC_HOPPER_TC_WARP_COL_TILES; ++col_tile) {
+                const int b_row = warp_col + col_tile * PYC_HOPPER_TC_MMA_TILE_N;
+                wmma::load_matrix_sync(b_frag[col_tile], &shared_b[b_row][k_frag], PYC_HOPPER_TC_SHARED_STRIDE_B);
+            }
+
+            for (int row_tile = 0; row_tile < PYC_HOPPER_TC_WARP_ROW_TILES; ++row_tile) {
+                for (int col_tile = 0; col_tile < PYC_HOPPER_TC_WARP_COL_TILES; ++col_tile) {
+                    wmma::mma_sync(acc[row_tile][col_tile], a_frag[row_tile], b_frag[col_tile], acc[row_tile][col_tile]);
+                }
+            }
+        }
+
+        __syncthreads();
+    }
+
+    for (int row_tile = 0; row_tile < PYC_HOPPER_TC_WARP_ROW_TILES; ++row_tile) {
+        const int c_row = block_row + warp_row + row_tile * PYC_HOPPER_TC_MMA_TILE_M;
+        for (int col_tile = 0; col_tile < PYC_HOPPER_TC_WARP_COL_TILES; ++col_tile) {
+            const int c_col = block_col + warp_col + col_tile * PYC_HOPPER_TC_MMA_TILE_N;
+            if (c_row < m && c_col < n) {
+                wmma::store_matrix_sync(&c[c_row * n + c_col], acc[row_tile][col_tile], n, wmma::mem_row_major);
+            }
+        }
+    }
+}
+
+static int set_kernel_attributes(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        pyc_hopper_tc_gemm_kernel,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, pyc_hopper_tc_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 5;
+    cfg->iters = 20;
+    cfg->skip_reference = env_flag("PYC_HOPPER_TC_SKIP_REFERENCE", 0);
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+    if (argc > 6 && parse_int_arg(argv[6], &cfg->skip_reference) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    pyc_hopper_tc_config cfg;
+    struct cudaDeviceProp props;
+    pyc_hopper_tc_scalar_t* host_a = NULL;
+    pyc_hopper_tc_scalar_t* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    pyc_hopper_tc_scalar_t* dev_a = NULL;
+    pyc_hopper_tc_scalar_t* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    double max_abs_diff = 0.0;
+    int iter;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters] [skip_reference]\n", argv[0]);
+        return 2;
+    }
+
+    if (
+        (cfg.m % PYC_HOPPER_TC_TILE_M) != 0 || (cfg.n % PYC_HOPPER_TC_TILE_N) != 0
+        || (cfg.k % PYC_HOPPER_TC_TILE_K) != 0) {
+        fprintf(
+            stderr,
+            "Hopper Tensor Core lane requires %dx%dx%d-aligned shapes\n",
+            PYC_HOPPER_TC_TILE_M,
+            PYC_HOPPER_TC_TILE_N,
+            PYC_HOPPER_TC_TILE_K);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDeviceProperties(&props, 0), "cudaGetDeviceProperties") != 0) {
+        return 1;
+    }
+    if (props.major < 9) {
+        fprintf(stderr, "Hopper Tensor Core prototype requires sm_90-class hardware\n");
+        return 1;
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(pyc_hopper_tc_scalar_t);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(pyc_hopper_tc_scalar_t);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (pyc_hopper_tc_scalar_t*)malloc(a_bytes);
+    host_b = (pyc_hopper_tc_scalar_t*)malloc(b_bytes);
+    if (!host_a || !host_b) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+    if (!cfg.skip_reference) {
+        host_c = (float*)malloc(c_bytes);
+        ref_c = (float*)malloc(c_bytes);
+        if (!host_c || !ref_c) {
+            fprintf(stderr, "host validation allocation failed\n");
+            return 1;
+        }
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    if (!cfg.skip_reference) {
+        reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+    }
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (set_kernel_attributes() != 0) return 1;
+
+    block = dim3(PYC_HOPPER_TC_THREADS_PER_BLOCK, 1, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_HOPPER_TC_TILE_N - 1) / PYC_HOPPER_TC_TILE_N),
+        (unsigned int)((cfg.m + PYC_HOPPER_TC_TILE_M - 1) / PYC_HOPPER_TC_TILE_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        pyc_hopper_tc_gemm_kernel<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        pyc_hopper_tc_gemm_kernel<<<grid, block>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (!cfg.skip_reference) {
+        if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+        for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+            double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+            if (diff > max_abs_diff) {
+                max_abs_diff = diff;
+            }
+        }
+    }
+
+    printf("kernel=hopper_tensor_core\n");
+    printf("lane=%s\n", PYC_HOPPER_TC_LANE_NAME);
+    printf("arch=sm%d%d\n", props.major, props.minor);
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf(
+        "tile=%dx%dx%d warp_tile=%dx%d warp_groups=%dx%d pads=%dx%d warps=%d threads=%d\n",
+        PYC_HOPPER_TC_TILE_M,
+        PYC_HOPPER_TC_TILE_N,
+        PYC_HOPPER_TC_TILE_K,
+        PYC_HOPPER_TC_WARP_TILE_M,
+        PYC_HOPPER_TC_WARP_TILE_N,
+        PYC_HOPPER_TC_WARP_ROW_GROUPS,
+        PYC_HOPPER_TC_WARP_COL_GROUPS,
+        PYC_HOPPER_TC_SHARED_PAD_A,
+        PYC_HOPPER_TC_SHARED_PAD_B,
+        PYC_HOPPER_TC_WARPS_PER_BLOCK,
+        PYC_HOPPER_TC_THREADS_PER_BLOCK);
+    printf("skip_reference=%d\n", cfg.skip_reference);
+    printf("best_ms=%.3f\n", best_ms);
+    if (!cfg.skip_reference) {
+        printf("max_abs_diff=%.6f\n", max_abs_diff);
+    }
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+        printf("tflops=%.3f\n", gflops / 1000.0);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return (cfg.skip_reference || max_abs_diff <= 0.2) ? 0 : 1;
+}

kernels/prototypes/hopper/tensor_core_async/kernel.cu

@@ -0,0 +1,612 @@
+#include <cuda_runtime.h>
+#include <mma.h>
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(PYC_HOPPER_TENSOR_CORE_USE_BF16) && PYC_HOPPER_TENSOR_CORE_USE_BF16
+#include <cuda_bf16.h>
+typedef __nv_bfloat16 pyc_hopper_tc_scalar_t;
+#define PYC_HOPPER_TC_LANE_NAME "bf16"
+static __host__ __device__ inline pyc_hopper_tc_scalar_t pyc_hopper_tc_make_scalar(float value) {
+    return __float2bfloat16(value);
+}
+static __host__ __device__ inline float pyc_hopper_tc_scalar_to_float(pyc_hopper_tc_scalar_t value) {
+    return __bfloat162float(value);
+}
+#else
+#include <cuda_fp16.h>
+typedef half pyc_hopper_tc_scalar_t;
+#define PYC_HOPPER_TC_LANE_NAME "fp16"
+static __host__ __device__ inline pyc_hopper_tc_scalar_t pyc_hopper_tc_make_scalar(float value) {
+    return __float2half(value);
+}
+static __host__ __device__ inline float pyc_hopper_tc_scalar_to_float(pyc_hopper_tc_scalar_t value) {
+    return __half2float(value);
+}
+#endif
+
+namespace wmma = nvcuda::wmma;
+
+#ifndef PYC_HOPPER_TC_MMA_TILE_M
+#define PYC_HOPPER_TC_MMA_TILE_M 16
+#endif
+
+#ifndef PYC_HOPPER_TC_MMA_TILE_N
+#define PYC_HOPPER_TC_MMA_TILE_N 16
+#endif
+
+#ifndef PYC_HOPPER_TC_MMA_TILE_K
+#define PYC_HOPPER_TC_MMA_TILE_K 16
+#endif
+
+#ifndef PYC_HOPPER_TC_WARP_ROW_TILES
+#define PYC_HOPPER_TC_WARP_ROW_TILES 2
+#endif
+
+#ifndef PYC_HOPPER_TC_WARP_COL_TILES
+#define PYC_HOPPER_TC_WARP_COL_TILES 2
+#endif
+
+#ifndef PYC_HOPPER_TC_WARP_ROW_GROUPS
+#define PYC_HOPPER_TC_WARP_ROW_GROUPS 2
+#endif
+
+#ifndef PYC_HOPPER_TC_WARP_COL_GROUPS
+#define PYC_HOPPER_TC_WARP_COL_GROUPS 2
+#endif
+
+#ifndef PYC_HOPPER_TC_TILE_K
+#define PYC_HOPPER_TC_TILE_K 32
+#endif
+
+#ifndef PYC_HOPPER_TC_SHARED_PAD_A
+#define PYC_HOPPER_TC_SHARED_PAD_A 8
+#endif
+
+#ifndef PYC_HOPPER_TC_SHARED_PAD_B
+#define PYC_HOPPER_TC_SHARED_PAD_B 8
+#endif
+
+#ifndef PYC_HOPPER_TC_STAGES
+#define PYC_HOPPER_TC_STAGES 2
+#endif
+
+#define PYC_HOPPER_TC_WARP_TILE_M (PYC_HOPPER_TC_MMA_TILE_M * PYC_HOPPER_TC_WARP_ROW_TILES)
+#define PYC_HOPPER_TC_WARP_TILE_N (PYC_HOPPER_TC_MMA_TILE_N * PYC_HOPPER_TC_WARP_COL_TILES)
+#define PYC_HOPPER_TC_TILE_M (PYC_HOPPER_TC_WARP_TILE_M * PYC_HOPPER_TC_WARP_ROW_GROUPS)
+#define PYC_HOPPER_TC_TILE_N (PYC_HOPPER_TC_WARP_TILE_N * PYC_HOPPER_TC_WARP_COL_GROUPS)
+#define PYC_HOPPER_TC_WARPS_PER_BLOCK (PYC_HOPPER_TC_WARP_ROW_GROUPS * PYC_HOPPER_TC_WARP_COL_GROUPS)
+#define PYC_HOPPER_TC_THREADS_PER_BLOCK (PYC_HOPPER_TC_WARPS_PER_BLOCK * 32)
+#define PYC_HOPPER_TC_SHARED_STRIDE_A (PYC_HOPPER_TC_TILE_K + PYC_HOPPER_TC_SHARED_PAD_A)
+#define PYC_HOPPER_TC_SHARED_STRIDE_B (PYC_HOPPER_TC_TILE_N + PYC_HOPPER_TC_SHARED_PAD_B)
+#define PYC_HOPPER_TC_STAGE_A_ELEMS (PYC_HOPPER_TC_TILE_M * PYC_HOPPER_TC_SHARED_STRIDE_A)
+#define PYC_HOPPER_TC_STAGE_B_ELEMS (PYC_HOPPER_TC_TILE_K * PYC_HOPPER_TC_SHARED_STRIDE_B)
+#define PYC_HOPPER_TC_STAGE_ELEMS (PYC_HOPPER_TC_STAGE_A_ELEMS + PYC_HOPPER_TC_STAGE_B_ELEMS)
+#define PYC_HOPPER_TC_SHARED_ELEMS (PYC_HOPPER_TC_STAGES * PYC_HOPPER_TC_STAGE_ELEMS)
+#define PYC_HOPPER_TC_SHARED_BYTES (PYC_HOPPER_TC_SHARED_ELEMS * (int)sizeof(pyc_hopper_tc_scalar_t))
+#define PYC_HOPPER_TC_COPY_BYTES 16
+#define PYC_HOPPER_TC_COPY_ELEMS (PYC_HOPPER_TC_COPY_BYTES / (int)sizeof(pyc_hopper_tc_scalar_t))
+
+typedef struct {
+    int m;
+    int n;
+    int k;
+    int warmup;
+    int iters;
+    int skip_reference;
+} pyc_hopper_tc_config;
+
+static int check_cuda(cudaError_t status, const char* what) {
+    if (status != cudaSuccess) {
+        fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
+        return -1;
+    }
+    return 0;
+}
+
+static int parse_int_arg(const char* text, int* out_value) {
+    char* end = NULL;
+    long parsed;
+    if (!text || !out_value) {
+        return -1;
+    }
+    parsed = strtol(text, &end, 10);
+    if (end == text || *end != '\0' || parsed < 0 || parsed > INT32_MAX) {
+        return -1;
+    }
+    *out_value = (int)parsed;
+    return 0;
+}
+
+static int env_flag(const char* name, int default_value) {
+    const char* raw = getenv(name);
+    if (!raw || raw[0] == '\0') {
+        return default_value;
+    }
+    if (
+        strcmp(raw, "1") == 0 || strcmp(raw, "true") == 0 || strcmp(raw, "TRUE") == 0
+        || strcmp(raw, "yes") == 0 || strcmp(raw, "on") == 0) {
+        return 1;
+    }
+    if (
+        strcmp(raw, "0") == 0 || strcmp(raw, "false") == 0 || strcmp(raw, "FALSE") == 0
+        || strcmp(raw, "no") == 0 || strcmp(raw, "off") == 0) {
+        return 0;
+    }
+    return default_value;
+}
+
+static void fill_matrix(pyc_hopper_tc_scalar_t* data, int rows, int cols, float scale) {
+    int i;
+    for (i = 0; i < rows * cols; ++i) {
+        int pattern = (i * 23 + rows * 13 + cols * 5) % 31;
+        data[i] = pyc_hopper_tc_make_scalar(((float)pattern - 15.0f) * scale);
+    }
+}
+
+static void reference_gemm(
+    const pyc_hopper_tc_scalar_t* a,
+    const pyc_hopper_tc_scalar_t* b,
+    float* c,
+    int m,
+    int n,
+    int k) {
+    int row;
+    for (row = 0; row < m; ++row) {
+        int col;
+        for (col = 0; col < n; ++col) {
+            float acc = 0.0f;
+            int kk;
+            for (kk = 0; kk < k; ++kk) {
+                acc += pyc_hopper_tc_scalar_to_float(a[row * k + kk]) * pyc_hopper_tc_scalar_to_float(b[kk * n + col]);
+            }
+            c[row * n + col] = acc;
+        }
+    }
+}
+
+__device__ static __forceinline__ void async_copy_16(void* dst, const void* src) {
+#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
+    unsigned int smem_addr = (unsigned int)__cvta_generic_to_shared(dst);
+    asm volatile("cp.async.ca.shared.global [%0], [%1], 16;\n" :: "r"(smem_addr), "l"(src));
+#else
+    *reinterpret_cast<int4*>(dst) = *reinterpret_cast<const int4*>(src);
+#endif
+}
+
+__device__ static __forceinline__ void async_commit(void) {
+#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
+    asm volatile("cp.async.commit_group;" ::: "memory");
+#endif
+}
+
+__device__ static __forceinline__ void async_wait(void) {
+#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
+    asm volatile("cp.async.wait_group 0;" ::: "memory");
+#endif
+}
+
+__device__ static __forceinline__ pyc_hopper_tc_scalar_t* shared_stage_base(
+    pyc_hopper_tc_scalar_t* shared_mem,
+    int stage) {
+    return shared_mem + stage * PYC_HOPPER_TC_STAGE_ELEMS;
+}
+
+__device__ static __forceinline__ pyc_hopper_tc_scalar_t* shared_stage_a(
+    pyc_hopper_tc_scalar_t* shared_mem,
+    int stage) {
+    return shared_stage_base(shared_mem, stage);
+}
+
+__device__ static __forceinline__ pyc_hopper_tc_scalar_t* shared_stage_b(
+    pyc_hopper_tc_scalar_t* shared_mem,
+    int stage) {
+    return shared_stage_a(shared_mem, stage) + PYC_HOPPER_TC_STAGE_A_ELEMS;
+}
+
+__device__ static __forceinline__ pyc_hopper_tc_scalar_t shared_a_load(
+    const pyc_hopper_tc_scalar_t* shared_a,
+    int row,
+    int col) {
+    return shared_a[row * PYC_HOPPER_TC_SHARED_STRIDE_A + col];
+}
+
+__device__ static __forceinline__ void shared_a_store(
+    pyc_hopper_tc_scalar_t* shared_a,
+    int row,
+    int col,
+    pyc_hopper_tc_scalar_t value) {
+    shared_a[row * PYC_HOPPER_TC_SHARED_STRIDE_A + col] = value;
+}
+
+__device__ static __forceinline__ void shared_b_store(
+    pyc_hopper_tc_scalar_t* shared_b,
+    int row,
+    int col,
+    pyc_hopper_tc_scalar_t value) {
+    shared_b[row * PYC_HOPPER_TC_SHARED_STRIDE_B + col] = value;
+}
+
+__device__ static void load_a_stage(
+    const pyc_hopper_tc_scalar_t* __restrict__ a,
+    pyc_hopper_tc_scalar_t* shared_a,
+    int lane_linear,
+    int block_row,
+    int kk_base,
+    int m,
+    int k) {
+    const int block_threads = PYC_HOPPER_TC_THREADS_PER_BLOCK;
+    const int vecs_per_row = PYC_HOPPER_TC_TILE_K / PYC_HOPPER_TC_COPY_ELEMS;
+    const int total_vecs = (PYC_HOPPER_TC_TILE_M * PYC_HOPPER_TC_TILE_K) / PYC_HOPPER_TC_COPY_ELEMS;
+    const int full_tile = (block_row + PYC_HOPPER_TC_TILE_M <= m) &&
+                          (kk_base + PYC_HOPPER_TC_TILE_K <= k) &&
+                          ((k & (PYC_HOPPER_TC_COPY_ELEMS - 1)) == 0);
+    int linear;
+
+    for (linear = lane_linear; linear < total_vecs; linear += block_threads) {
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_HOPPER_TC_COPY_ELEMS;
+        const int global_row = block_row + tile_row;
+        const int global_col = kk_base + tile_col;
+        int i;
+
+        if (full_tile) {
+            async_copy_16(
+                &shared_a[tile_row * PYC_HOPPER_TC_SHARED_STRIDE_A + tile_col],
+                &a[global_row * k + global_col]);
+            continue;
+        }
+
+        for (i = 0; i < PYC_HOPPER_TC_COPY_ELEMS; ++i) {
+            pyc_hopper_tc_scalar_t value = pyc_hopper_tc_make_scalar(0.0f);
+            if (global_row < m && global_col + i < k) {
+                value = a[global_row * k + global_col + i];
+            }
+            shared_a_store(shared_a, tile_row, tile_col + i, value);
+        }
+    }
+}
+
+__device__ static void load_b_stage(
+    const pyc_hopper_tc_scalar_t* __restrict__ b,
+    pyc_hopper_tc_scalar_t* shared_b,
+    int lane_linear,
+    int block_col,
+    int kk_base,
+    int k,
+    int n) {
+    const int block_threads = PYC_HOPPER_TC_THREADS_PER_BLOCK;
+    const int vecs_per_row = PYC_HOPPER_TC_TILE_N / PYC_HOPPER_TC_COPY_ELEMS;
+    const int total_vecs = (PYC_HOPPER_TC_TILE_K * PYC_HOPPER_TC_TILE_N) / PYC_HOPPER_TC_COPY_ELEMS;
+    const int full_tile = (block_col + PYC_HOPPER_TC_TILE_N <= n) &&
+                          (kk_base + PYC_HOPPER_TC_TILE_K <= k) &&
+                          ((n & (PYC_HOPPER_TC_COPY_ELEMS - 1)) == 0);
+    int linear;
+
+    for (linear = lane_linear; linear < total_vecs; linear += block_threads) {
+        const int tile_row = linear / vecs_per_row;
+        const int tile_col = (linear % vecs_per_row) * PYC_HOPPER_TC_COPY_ELEMS;
+        const int global_row = kk_base + tile_row;
+        const int global_col = block_col + tile_col;
+        int i;
+
+        if (full_tile) {
+            async_copy_16(
+                &shared_b[tile_row * PYC_HOPPER_TC_SHARED_STRIDE_B + tile_col],
+                &b[global_row * n + global_col]);
+            continue;
+        }
+
+        for (i = 0; i < PYC_HOPPER_TC_COPY_ELEMS; ++i) {
+            pyc_hopper_tc_scalar_t value = pyc_hopper_tc_make_scalar(0.0f);
+            if (global_row < k && global_col + i < n) {
+                value = b[global_row * n + global_col + i];
+            }
+            shared_b_store(shared_b, tile_row, tile_col + i, value);
+        }
+    }
+}
+
+__launch_bounds__(PYC_HOPPER_TC_THREADS_PER_BLOCK, 2)
+__global__ void pyc_hopper_tc_async_gemm_kernel(
+    const pyc_hopper_tc_scalar_t* __restrict__ a,
+    const pyc_hopper_tc_scalar_t* __restrict__ b,
+    float* __restrict__ c,
+    int m,
+    int n,
+    int k) {
+    extern __shared__ __align__(16) pyc_hopper_tc_scalar_t shared_mem[];
+
+    const int lane_linear = threadIdx.x;
+    const int warp_id = threadIdx.x / 32;
+    const int block_row = blockIdx.y * PYC_HOPPER_TC_TILE_M;
+    const int block_col = blockIdx.x * PYC_HOPPER_TC_TILE_N;
+    const int warp_row_group = warp_id / PYC_HOPPER_TC_WARP_COL_GROUPS;
+    const int warp_col_group = warp_id % PYC_HOPPER_TC_WARP_COL_GROUPS;
+    const int warp_row = warp_row_group * PYC_HOPPER_TC_WARP_TILE_M;
+    const int warp_col = warp_col_group * PYC_HOPPER_TC_WARP_TILE_N;
+    wmma::fragment<wmma::accumulator, 16, 16, 16, float> acc[PYC_HOPPER_TC_WARP_ROW_TILES][PYC_HOPPER_TC_WARP_COL_TILES];
+    int stage = 0;
+    int kk_base;
+
+    if (warp_id >= PYC_HOPPER_TC_WARPS_PER_BLOCK) {
+        return;
+    }
+
+    for (int row_tile = 0; row_tile < PYC_HOPPER_TC_WARP_ROW_TILES; ++row_tile) {
+        for (int col_tile = 0; col_tile < PYC_HOPPER_TC_WARP_COL_TILES; ++col_tile) {
+            wmma::fill_fragment(acc[row_tile][col_tile], 0.0f);
+        }
+    }
+
+    load_a_stage(a, shared_stage_a(shared_mem, stage), lane_linear, block_row, 0, m, k);
+    load_b_stage(b, shared_stage_b(shared_mem, stage), lane_linear, block_col, 0, k, n);
+    async_commit();
+    async_wait();
+    __syncthreads();
+
+    for (kk_base = 0; kk_base < k; kk_base += PYC_HOPPER_TC_TILE_K) {
+        const int next_kk = kk_base + PYC_HOPPER_TC_TILE_K;
+        const int next_stage = stage ^ 1;
+
+        if (next_kk < k) {
+            load_a_stage(a, shared_stage_a(shared_mem, next_stage), lane_linear, block_row, next_kk, m, k);
+            load_b_stage(b, shared_stage_b(shared_mem, next_stage), lane_linear, block_col, next_kk, k, n);
+            async_commit();
+        }
+
+        for (int k_frag = 0; k_frag < PYC_HOPPER_TC_TILE_K; k_frag += PYC_HOPPER_TC_MMA_TILE_K) {
+            wmma::fragment<wmma::matrix_a, 16, 16, 16, pyc_hopper_tc_scalar_t, wmma::row_major> a_frag[PYC_HOPPER_TC_WARP_ROW_TILES];
+            wmma::fragment<wmma::matrix_b, 16, 16, 16, pyc_hopper_tc_scalar_t, wmma::row_major> b_frag[PYC_HOPPER_TC_WARP_COL_TILES];
+
+            for (int row_tile = 0; row_tile < PYC_HOPPER_TC_WARP_ROW_TILES; ++row_tile) {
+                const int a_row = warp_row + row_tile * PYC_HOPPER_TC_MMA_TILE_M;
+                wmma::load_matrix_sync(
+                    a_frag[row_tile],
+                    &shared_stage_a(shared_mem, stage)[a_row * PYC_HOPPER_TC_SHARED_STRIDE_A + k_frag],
+                    PYC_HOPPER_TC_SHARED_STRIDE_A);
+            }
+
+            for (int col_tile = 0; col_tile < PYC_HOPPER_TC_WARP_COL_TILES; ++col_tile) {
+                const int b_col = warp_col + col_tile * PYC_HOPPER_TC_MMA_TILE_N;
+                wmma::load_matrix_sync(
+                    b_frag[col_tile],
+                    &shared_stage_b(shared_mem, stage)[k_frag * PYC_HOPPER_TC_SHARED_STRIDE_B + b_col],
+                    PYC_HOPPER_TC_SHARED_STRIDE_B);
+            }
+
+            for (int row_tile = 0; row_tile < PYC_HOPPER_TC_WARP_ROW_TILES; ++row_tile) {
+                for (int col_tile = 0; col_tile < PYC_HOPPER_TC_WARP_COL_TILES; ++col_tile) {
+                    wmma::mma_sync(acc[row_tile][col_tile], a_frag[row_tile], b_frag[col_tile], acc[row_tile][col_tile]);
+                }
+            }
+        }
+
+        if (next_kk < k) {
+            async_wait();
+            __syncthreads();
+            stage = next_stage;
+        }
+    }
+
+    for (int row_tile = 0; row_tile < PYC_HOPPER_TC_WARP_ROW_TILES; ++row_tile) {
+        const int c_row = block_row + warp_row + row_tile * PYC_HOPPER_TC_MMA_TILE_M;
+        for (int col_tile = 0; col_tile < PYC_HOPPER_TC_WARP_COL_TILES; ++col_tile) {
+            const int c_col = block_col + warp_col + col_tile * PYC_HOPPER_TC_MMA_TILE_N;
+            if (c_row < m && c_col < n) {
+                wmma::store_matrix_sync(&c[c_row * n + c_col], acc[row_tile][col_tile], n, wmma::mem_row_major);
+            }
+        }
+    }
+}
+
+static int set_kernel_attributes(void) {
+    cudaError_t status;
+
+    status = cudaFuncSetAttribute(
+        pyc_hopper_tc_async_gemm_kernel,
+        cudaFuncAttributeMaxDynamicSharedMemorySize,
+        PYC_HOPPER_TC_SHARED_BYTES);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute(max_dynamic_shared) failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    status = cudaFuncSetAttribute(
+        pyc_hopper_tc_async_gemm_kernel,
+        cudaFuncAttributePreferredSharedMemoryCarveout,
+        100);
+    if (status != cudaSuccess && status != cudaErrorNotSupported) {
+        fprintf(stderr, "cudaFuncSetAttribute failed: %s\n", cudaGetErrorString(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_config(int argc, char** argv, pyc_hopper_tc_config* cfg) {
+    if (!cfg) {
+        return -1;
+    }
+
+    cfg->m = 1024;
+    cfg->n = 1024;
+    cfg->k = 1024;
+    cfg->warmup = 5;
+    cfg->iters = 20;
+    cfg->skip_reference = env_flag("PYC_HOPPER_TC_SKIP_REFERENCE", 0);
+
+    if (argc > 1 && parse_int_arg(argv[1], &cfg->m) != 0) return -1;
+    if (argc > 2 && parse_int_arg(argv[2], &cfg->n) != 0) return -1;
+    if (argc > 3 && parse_int_arg(argv[3], &cfg->k) != 0) return -1;
+    if (argc > 4 && parse_int_arg(argv[4], &cfg->warmup) != 0) return -1;
+    if (argc > 5 && parse_int_arg(argv[5], &cfg->iters) != 0) return -1;
+    if (argc > 6 && parse_int_arg(argv[6], &cfg->skip_reference) != 0) return -1;
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    pyc_hopper_tc_config cfg;
+    struct cudaDeviceProp props;
+    pyc_hopper_tc_scalar_t* host_a = NULL;
+    pyc_hopper_tc_scalar_t* host_b = NULL;
+    float* host_c = NULL;
+    float* ref_c = NULL;
+    pyc_hopper_tc_scalar_t* dev_a = NULL;
+    pyc_hopper_tc_scalar_t* dev_b = NULL;
+    float* dev_c = NULL;
+    cudaEvent_t start = NULL;
+    cudaEvent_t stop = NULL;
+    size_t a_bytes;
+    size_t b_bytes;
+    size_t c_bytes;
+    dim3 block;
+    dim3 grid;
+    float elapsed_ms = 0.0f;
+    double best_ms = 0.0;
+    double max_abs_diff = 0.0;
+    int iter;
+
+    if (parse_config(argc, argv, &cfg) != 0) {
+        fprintf(stderr, "usage: %s [m] [n] [k] [warmup] [iters] [skip_reference]\n", argv[0]);
+        return 2;
+    }
+
+    if (
+        (cfg.m % PYC_HOPPER_TC_TILE_M) != 0 || (cfg.n % PYC_HOPPER_TC_TILE_N) != 0
+        || (cfg.k % PYC_HOPPER_TC_TILE_K) != 0) {
+        fprintf(
+            stderr,
+            "Hopper Tensor Core async lane requires %dx%dx%d-aligned shapes\n",
+            PYC_HOPPER_TC_TILE_M,
+            PYC_HOPPER_TC_TILE_N,
+            PYC_HOPPER_TC_TILE_K);
+        return 2;
+    }
+
+    if (check_cuda(cudaGetDeviceProperties(&props, 0), "cudaGetDeviceProperties") != 0) {
+        return 1;
+    }
+    if (props.major < 9) {
+        fprintf(stderr, "Hopper Tensor Core async prototype requires sm_90-class hardware\n");
+        return 1;
+    }
+
+    a_bytes = (size_t)cfg.m * (size_t)cfg.k * sizeof(pyc_hopper_tc_scalar_t);
+    b_bytes = (size_t)cfg.k * (size_t)cfg.n * sizeof(pyc_hopper_tc_scalar_t);
+    c_bytes = (size_t)cfg.m * (size_t)cfg.n * sizeof(float);
+
+    host_a = (pyc_hopper_tc_scalar_t*)malloc(a_bytes);
+    host_b = (pyc_hopper_tc_scalar_t*)malloc(b_bytes);
+    if (!host_a || !host_b) {
+        fprintf(stderr, "host allocation failed\n");
+        return 1;
+    }
+    if (!cfg.skip_reference) {
+        host_c = (float*)malloc(c_bytes);
+        ref_c = (float*)malloc(c_bytes);
+        if (!host_c || !ref_c) {
+            fprintf(stderr, "host validation allocation failed\n");
+            return 1;
+        }
+    }
+
+    fill_matrix(host_a, cfg.m, cfg.k, 0.03125f);
+    fill_matrix(host_b, cfg.k, cfg.n, 0.0625f);
+    if (!cfg.skip_reference) {
+        reference_gemm(host_a, host_b, ref_c, cfg.m, cfg.n, cfg.k);
+    }
+
+    if (check_cuda(cudaMalloc((void**)&dev_a, a_bytes), "cudaMalloc(a)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_b, b_bytes), "cudaMalloc(b)") != 0) return 1;
+    if (check_cuda(cudaMalloc((void**)&dev_c, c_bytes), "cudaMalloc(c)") != 0) return 1;
+
+    if (check_cuda(cudaMemcpy(dev_a, host_a, a_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(a)") != 0) return 1;
+    if (check_cuda(cudaMemcpy(dev_b, host_b, b_bytes, cudaMemcpyHostToDevice), "cudaMemcpy(b)") != 0) return 1;
+
+    if (set_kernel_attributes() != 0) return 1;
+
+    block = dim3(PYC_HOPPER_TC_THREADS_PER_BLOCK, 1, 1);
+    grid = dim3(
+        (unsigned int)((cfg.n + PYC_HOPPER_TC_TILE_N - 1) / PYC_HOPPER_TC_TILE_N),
+        (unsigned int)((cfg.m + PYC_HOPPER_TC_TILE_M - 1) / PYC_HOPPER_TC_TILE_M),
+        1);
+
+    if (check_cuda(cudaEventCreate(&start), "cudaEventCreate(start)") != 0) return 1;
+    if (check_cuda(cudaEventCreate(&stop), "cudaEventCreate(stop)") != 0) return 1;
+
+    for (iter = 0; iter < cfg.warmup; ++iter) {
+        pyc_hopper_tc_async_gemm_kernel<<<grid, block, PYC_HOPPER_TC_SHARED_BYTES>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+    }
+    if (check_cuda(cudaGetLastError(), "kernel launch warmup") != 0) return 1;
+    if (check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize warmup") != 0) return 1;
+
+    best_ms = 0.0;
+    for (iter = 0; iter < cfg.iters; ++iter) {
+        if (check_cuda(cudaEventRecord(start), "cudaEventRecord(start)") != 0) return 1;
+        pyc_hopper_tc_async_gemm_kernel<<<grid, block, PYC_HOPPER_TC_SHARED_BYTES>>>(dev_a, dev_b, dev_c, cfg.m, cfg.n, cfg.k);
+        if (check_cuda(cudaEventRecord(stop), "cudaEventRecord(stop)") != 0) return 1;
+        if (check_cuda(cudaEventSynchronize(stop), "cudaEventSynchronize(stop)") != 0) return 1;
+        if (check_cuda(cudaEventElapsedTime(&elapsed_ms, start, stop), "cudaEventElapsedTime") != 0) return 1;
+        if (iter == 0 || elapsed_ms < (float)best_ms) {
+            best_ms = elapsed_ms;
+        }
+    }
+
+    if (!cfg.skip_reference) {
+        if (check_cuda(cudaMemcpy(host_c, dev_c, c_bytes, cudaMemcpyDeviceToHost), "cudaMemcpy(c)") != 0) return 1;
+        for (iter = 0; iter < cfg.m * cfg.n; ++iter) {
+            double diff = fabs((double)host_c[iter] - (double)ref_c[iter]);
+            if (diff > max_abs_diff) {
+                max_abs_diff = diff;
+            }
+        }
+    }
+
+    printf("kernel=hopper_tensor_core_async\n");
+    printf("lane=%s\n", PYC_HOPPER_TC_LANE_NAME);
+    printf("arch=sm%d%d\n", props.major, props.minor);
+    printf("shape=%dx%dx%d\n", cfg.m, cfg.n, cfg.k);
+    printf(
+        "tile=%dx%dx%d warp_tile=%dx%d warp_groups=%dx%d pads=%dx%d warps=%d threads=%d stages=%d shared_bytes=%d\n",
+        PYC_HOPPER_TC_TILE_M,
+        PYC_HOPPER_TC_TILE_N,
+        PYC_HOPPER_TC_TILE_K,
+        PYC_HOPPER_TC_WARP_TILE_M,
+        PYC_HOPPER_TC_WARP_TILE_N,
+        PYC_HOPPER_TC_WARP_ROW_GROUPS,
+        PYC_HOPPER_TC_WARP_COL_GROUPS,
+        PYC_HOPPER_TC_SHARED_PAD_A,
+        PYC_HOPPER_TC_SHARED_PAD_B,
+        PYC_HOPPER_TC_WARPS_PER_BLOCK,
+        PYC_HOPPER_TC_THREADS_PER_BLOCK,
+        PYC_HOPPER_TC_STAGES,
+        PYC_HOPPER_TC_SHARED_BYTES);
+    printf("skip_reference=%d\n", cfg.skip_reference);
+    printf("best_ms=%.3f\n", best_ms);
+    if (!cfg.skip_reference) {
+        printf("max_abs_diff=%.6f\n", max_abs_diff);
+    }
+    if (best_ms > 0.0) {
+        double flops = 2.0 * (double)cfg.m * (double)cfg.n * (double)cfg.k;
+        double gflops = flops / (best_ms * 1.0e6);
+        printf("gflops=%.3f\n", gflops);
+        printf("tflops=%.3f\n", gflops / 1000.0);
+    }
+
+    cudaEventDestroy(start);
+    cudaEventDestroy(stop);
+    cudaFree(dev_a);
+    cudaFree(dev_b);
+    cudaFree(dev_c);
+    free(host_a);
+    free(host_b);
+    free(host_c);
+    free(ref_c);
+    return (cfg.skip_reference || max_abs_diff <= 0.2) ? 0 : 1;
+}

kernels/prototypes/hopper/tensor_core_wgmma/README.md

@@ -0,0 +1,28 @@
+# Hopper Tensor Core WGMMA Lane
+
+This directory is reserved for the Hopper-native gap-closing kernel lane.
+
+Current state:
+
+- `tensor_core_async` is the owned WMMA guardrail lane.
+- `cuBLASLt` is the control ceiling lane.
+- `tensor_core_wgmma` is the next implementation lane intended to close the remaining device-side gap.
+
+Minimum contract for the first implementation:
+
+- target shape: `4096x4096x4096`
+- dtype: BF16 input, FP32 accumulation
+- architecture: `sm90`
+- correctness lane: `512x512x512` with reference enabled
+- performance lane: `4096x4096x4096` with reference disabled
+
+Design goals:
+
+- use warpgroup MMA rather than per-warp WMMA
+- move toward TMA-backed staging for the long-term feed path
+- preserve a standalone harness so the lane can be benchmarked by `kernel_lab`
+- keep the first fast path simple: no generalized epilogue work unless it is proven necessary
+
+Promotion rule:
+
+- only promote a `tensor_core_wgmma` variant if it beats the current owned SM90 baseline without correctness regressions

manifests/lab_kernels.json

@@ -0,0 +1,156 @@
+{
+  "kernels": [
+    {
+      "name": "matrix_mult",
+      "source": "kernels/prototypes/baseline/matmul/kernel.cu",
+      "description": "CUDA matrix multiplication kernel (compile-only baseline).",
+      "tags": ["cuda", "matmul"],
+      "compile_cmd": "{nvcc} -O3 -c {source} -o {build_dir}/{name}.o",
+      "run_cmd": ""
+    },
+    {
+      "name": "tokenizer_kernel",
+      "source": "kernels/prototypes/experimental/tokenizer_matmul/kernel.cu",
+      "description": "Experimental tokenizer/matrix CUDA kernel file.",
+      "tags": ["cuda", "tokenizer", "experimental"],
+      "compile_cmd": "{nvcc} -O2 -c {source} -o {build_dir}/{name}.o",
+      "run_cmd": ""
+    },
+    {
+      "name": "ada_gemm",
+      "source": "kernels/prototypes/ada/gemm/kernel.cu",
+      "description": "Ada-focused FP32 shared-memory GEMM prototype with standalone correctness and timing harness.",
+      "tags": ["cuda", "matmul", "ada", "sm89", "prototype"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -gencode arch=compute_89,code=sm_89 -gencode arch=compute_89,code=compute_89 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 10 50"
+    },
+    {
+      "name": "ada_gemm_k64_warp32_async",
+      "source": "kernels/prototypes/ada/gemm_k64_warp32_async/kernel.cu",
+      "description": "Ada FP32 GEMM winner with 64x64x64 tiles, 32x8 threads, and cp.async double-buffered shared-memory stages.",
+      "tags": ["cuda", "matmul", "ada", "sm89", "prototype", "fp32", "vectorized", "winner", "k64", "warp32", "async", "cpasync"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -gencode arch=compute_89,code=sm_89 -gencode arch=compute_89,code=compute_89 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 10 50"
+    },
+    {
+      "name": "ada_tensor_core_fp16",
+      "source": "kernels/prototypes/ada/tensor_core/kernel.cu",
+      "description": "Ada Tensor Core FP16 GEMM prototype with WMMA-backed 32x64x16 correctness and timing harness.",
+      "tags": ["cuda", "matmul", "ada", "sm89", "prototype", "tensor-core", "fp16"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_ADA_TENSOR_CORE_USE_BF16=0 -gencode arch=compute_89,code=sm_89 -gencode arch=compute_89,code=compute_89 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 10 50"
+    },
+    {
+      "name": "ada_tensor_core_bf16",
+      "source": "kernels/prototypes/ada/tensor_core/kernel.cu",
+      "description": "Ada Tensor Core BF16 GEMM prototype with WMMA-backed 32x64x16 correctness and timing harness.",
+      "tags": ["cuda", "matmul", "ada", "sm89", "prototype", "tensor-core", "bf16"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_ADA_TENSOR_CORE_USE_BF16=1 -gencode arch=compute_89,code=sm_89 -gencode arch=compute_89,code=compute_89 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 10 50"
+    },
+    {
+      "name": "hopper_tensor_core_fp16",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper Tensor Core FP16 GEMM prototype with a 64x64x16 WMMA tile and larger per-block warpgroup-style work.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "fp16"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=0 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 5 20"
+    },
+    {
+      "name": "hopper_tensor_core_bf16",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper Tensor Core BF16 GEMM prototype with a 64x64x16 WMMA tile and larger per-block warpgroup-style work.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 5 20"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_perf",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper BF16 baseline perf lane at 4096^3 with reference disabled to isolate steady-state Tensor Core throughput.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "perf", "next-loop"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_warp2n",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper BF16 perf lane with 8 warps per CTA and each warp computing two N fragments to increase work per warp.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "perf", "next-loop", "warp2n"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_COL_TILES=2 -DPYC_HOPPER_TC_WARP_ROW_GROUPS=4 -DPYC_HOPPER_TC_WARP_COL_GROUPS=2 -DPYC_HOPPER_TC_SHARED_PAD_A=8 -DPYC_HOPPER_TC_SHARED_PAD_B=8 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_k32",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper BF16 perf lane with a 64x64x32 shared-memory stage to cut synchronization frequency across K.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "perf", "next-loop", "k32"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_TILE_K=32 -DPYC_HOPPER_TC_SHARED_PAD_A=8 -DPYC_HOPPER_TC_SHARED_PAD_B=8 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_warp2n_k32",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper BF16 perf lane combining 8-warp CTAs, two N fragments per warp, padded shared-memory strides, and 32-wide K staging.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "perf", "next-loop", "warp2n", "k32"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_COL_TILES=2 -DPYC_HOPPER_TC_WARP_ROW_GROUPS=4 -DPYC_HOPPER_TC_WARP_COL_GROUPS=2 -DPYC_HOPPER_TC_TILE_K=32 -DPYC_HOPPER_TC_SHARED_PAD_A=8 -DPYC_HOPPER_TC_SHARED_PAD_B=8 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_cublaslt_bf16",
+      "source": "kernels/prototypes/hopper/cublaslt_bf16/kernel.cu",
+      "description": "Hopper cuBLASLt BF16 GEMM control lane for measuring the hardware-native library ceiling before a custom TMA/WGMMA implementation lands.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "cublaslt", "bf16", "control", "ceiling"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -lcublasLt -lcublas -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_cublaslt_bf16_check",
+      "source": "kernels/prototypes/hopper/cublaslt_bf16/kernel.cu",
+      "description": "Smaller Hopper cuBLASLt BF16 correctness lane with reference enabled.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "cublaslt", "bf16", "correctness"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -lcublasLt -lcublas -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 512 512 512 2 10 0"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_async",
+      "source": "kernels/prototypes/hopper/tensor_core_async/kernel.cu",
+      "description": "Hopper BF16 async WMMA lane with cp.async double-buffered staging, 64x64x32 tiles, and four fragments per warp to cut exposed feed bubbles.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "async", "cpasync", "double-buffered"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_async_wide",
+      "source": "kernels/prototypes/hopper/tensor_core_async/kernel.cu",
+      "description": "Hopper BF16 async WMMA lane widened to a 64x128x32 CTA so each stage amortizes more scheduling overhead before the WGMMA/TMA path lands.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "async", "cpasync", "double-buffered", "wide"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_COL_GROUPS=4 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_async_wide_k64",
+      "source": "kernels/prototypes/hopper/tensor_core_async/kernel.cu",
+      "description": "Hopper BF16 async WMMA lane keeping the 64x128 CTA but doubling stage depth to 64 so each stage amortizes more feed and loop overhead.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "async", "cpasync", "double-buffered", "wide", "k64", "gap-close"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_COL_GROUPS=4 -DPYC_HOPPER_TC_TILE_K=64 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_async_square",
+      "source": "kernels/prototypes/hopper/tensor_core_async/kernel.cu",
+      "description": "Hopper BF16 async WMMA lane widened into a 128x128x32 CTA so the square 4096^3 regime gets more work per CTA before switching stages.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "async", "cpasync", "double-buffered", "square", "gap-close"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_ROW_GROUPS=4 -DPYC_HOPPER_TC_WARP_COL_GROUPS=4 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_async_square_k64",
+      "source": "kernels/prototypes/hopper/tensor_core_async/kernel.cu",
+      "description": "Hopper BF16 async WMMA square lane with a 128x128x64 CTA to test the last cheap work-per-stage lever before the WGMMA/TMA path takes over.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "async", "cpasync", "double-buffered", "square", "k64", "gap-close"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_ROW_GROUPS=4 -DPYC_HOPPER_TC_WARP_COL_GROUPS=4 -DPYC_HOPPER_TC_TILE_K=64 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    }
+  ]
+}

manifests/registry_kernels.json

@@ -0,0 +1,157 @@
+{
+  "schema_version": 1,
+  "kernels": [
+    {
+      "name": "matrix_mult",
+      "source": "kernels/prototypes/baseline/matmul/kernel.cu",
+      "description": "CUDA matrix multiplication kernel (compile-only baseline).",
+      "tags": ["cuda", "matmul"],
+      "compile_cmd": "{nvcc} -O3 -c {source} -o {build_dir}/{name}.o",
+      "run_cmd": ""
+    },
+    {
+      "name": "tokenizer_kernel",
+      "source": "kernels/prototypes/experimental/tokenizer_matmul/kernel.cu",
+      "description": "Experimental tokenizer/matrix CUDA kernel file.",
+      "tags": ["cuda", "tokenizer", "experimental"],
+      "compile_cmd": "{nvcc} -O2 -c {source} -o {build_dir}/{name}.o",
+      "run_cmd": ""
+    },
+    {
+      "name": "ada_gemm",
+      "source": "kernels/prototypes/ada/gemm/kernel.cu",
+      "description": "Ada-focused FP32 shared-memory GEMM prototype with standalone correctness and timing harness.",
+      "tags": ["cuda", "matmul", "ada", "sm89", "prototype"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -gencode arch=compute_89,code=sm_89 -gencode arch=compute_89,code=compute_89 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 10 50"
+    },
+    {
+      "name": "ada_gemm_k64_warp32_async",
+      "source": "kernels/prototypes/ada/gemm_k64_warp32_async/kernel.cu",
+      "description": "Ada FP32 GEMM winner with 64x64x64 tiles, 32x8 threads, and cp.async double-buffered shared-memory stages.",
+      "tags": ["cuda", "matmul", "ada", "sm89", "prototype", "fp32", "vectorized", "winner", "k64", "warp32", "async", "cpasync"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -gencode arch=compute_89,code=sm_89 -gencode arch=compute_89,code=compute_89 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 10 50"
+    },
+    {
+      "name": "ada_tensor_core_fp16",
+      "source": "kernels/prototypes/ada/tensor_core/kernel.cu",
+      "description": "Ada Tensor Core FP16 GEMM prototype.",
+      "tags": ["cuda", "matmul", "ada", "sm89", "prototype", "tensor-core", "fp16"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_ADA_TENSOR_CORE_USE_BF16=0 -gencode arch=compute_89,code=sm_89 -gencode arch=compute_89,code=compute_89 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 10 50"
+    },
+    {
+      "name": "ada_tensor_core_bf16",
+      "source": "kernels/prototypes/ada/tensor_core/kernel.cu",
+      "description": "Ada Tensor Core BF16 GEMM prototype.",
+      "tags": ["cuda", "matmul", "ada", "sm89", "prototype", "tensor-core", "bf16"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_ADA_TENSOR_CORE_USE_BF16=1 -gencode arch=compute_89,code=sm_89 -gencode arch=compute_89,code=compute_89 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 10 50"
+    },
+    {
+      "name": "hopper_tensor_core_fp16",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper Tensor Core FP16 GEMM prototype.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "fp16"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=0 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 5 20"
+    },
+    {
+      "name": "hopper_tensor_core_bf16",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper Tensor Core BF16 GEMM prototype.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 1024 1024 1024 5 20"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_perf",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper BF16 baseline performance lane.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "perf"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_warp2n",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper BF16 performance lane with two N fragments per warp.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "perf", "warp2n"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_COL_TILES=2 -DPYC_HOPPER_TC_WARP_ROW_GROUPS=4 -DPYC_HOPPER_TC_WARP_COL_GROUPS=2 -DPYC_HOPPER_TC_SHARED_PAD_A=8 -DPYC_HOPPER_TC_SHARED_PAD_B=8 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_k32",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper BF16 performance lane with 32-wide K staging.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "perf", "k32"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_TILE_K=32 -DPYC_HOPPER_TC_SHARED_PAD_A=8 -DPYC_HOPPER_TC_SHARED_PAD_B=8 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_warp2n_k32",
+      "source": "kernels/prototypes/hopper/tensor_core/kernel.cu",
+      "description": "Hopper BF16 performance lane combining warp2n and 32-wide K staging.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "perf", "warp2n", "k32"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_COL_TILES=2 -DPYC_HOPPER_TC_WARP_ROW_GROUPS=4 -DPYC_HOPPER_TC_WARP_COL_GROUPS=2 -DPYC_HOPPER_TC_TILE_K=32 -DPYC_HOPPER_TC_SHARED_PAD_A=8 -DPYC_HOPPER_TC_SHARED_PAD_B=8 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_cublaslt_bf16",
+      "source": "kernels/prototypes/hopper/cublaslt_bf16/kernel.cu",
+      "description": "Hopper cuBLASLt BF16 GEMM control lane.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "cublaslt", "bf16", "control"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -lcublasLt -lcublas -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_cublaslt_bf16_check",
+      "source": "kernels/prototypes/hopper/cublaslt_bf16/kernel.cu",
+      "description": "Smaller Hopper cuBLASLt BF16 correctness lane.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "cublaslt", "bf16", "correctness"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -lcublasLt -lcublas -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 512 512 512 2 10 0"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_async",
+      "source": "kernels/prototypes/hopper/tensor_core_async/kernel.cu",
+      "description": "Hopper BF16 async WMMA lane with double-buffered staging.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "async", "cpasync"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_async_wide",
+      "source": "kernels/prototypes/hopper/tensor_core_async/kernel.cu",
+      "description": "Hopper BF16 async WMMA lane widened to a 64x128 CTA.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "async", "wide"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_COL_GROUPS=4 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_async_wide_k64",
+      "source": "kernels/prototypes/hopper/tensor_core_async/kernel.cu",
+      "description": "Hopper BF16 async WMMA wide lane with K=64 staging.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "async", "wide", "k64"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_COL_GROUPS=4 -DPYC_HOPPER_TC_TILE_K=64 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_async_square",
+      "source": "kernels/prototypes/hopper/tensor_core_async/kernel.cu",
+      "description": "Hopper BF16 async WMMA lane widened to a 128x128 CTA.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "async", "square"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_ROW_GROUPS=4 -DPYC_HOPPER_TC_WARP_COL_GROUPS=4 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    },
+    {
+      "name": "hopper_tensor_core_bf16_async_square_k64",
+      "source": "kernels/prototypes/hopper/tensor_core_async/kernel.cu",
+      "description": "Hopper BF16 async WMMA square lane with K=64 staging.",
+      "tags": ["cuda", "matmul", "hopper", "sm90", "prototype", "tensor-core", "bf16", "async", "square", "k64"],
+      "compile_cmd": "{nvcc} -O3 -std=c++17 -lineinfo -DPYC_HOPPER_TENSOR_CORE_USE_BF16=1 -DPYC_HOPPER_TC_WARP_ROW_GROUPS=4 -DPYC_HOPPER_TC_WARP_COL_GROUPS=4 -DPYC_HOPPER_TC_TILE_K=64 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90 {source} -o {build_dir}/{name}",
+      "run_cmd": "{build_dir}/{name} 4096 4096 4096 3 30 1"
+    }
+  ]
+}