{"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Arenas_email (level: level1_small)\nShape: 1133 x 1133\nNon-zeros: 10902 (avg nnz/row ≈ 9.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Arenas_email.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Arenas_email", "num_rows": 1133, "num_cols": 1133, "nnz": 10902} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bai_rbsb480 (level: level1_small)\nShape: 480 x 480\nNon-zeros: 17088 (avg nnz/row ≈ 35.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Bai_rbsb480.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Bai_rbsb480", "num_rows": 480, "num_cols": 480, "nnz": 17088} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Boeing_msc00726 (level: level1_small)\nShape: 726 x 726\nNon-zeros: 34518 (avg nnz/row ≈ 47.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Boeing_msc00726.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Boeing_msc00726", "num_rows": 726, "num_cols": 726, "nnz": 34518} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Boeing_nasa1824 (level: level1_small)\nShape: 1824 x 1824\nNon-zeros: 39208 (avg nnz/row ≈ 21.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Boeing_nasa1824.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Boeing_nasa1824", "num_rows": 1824, "num_cols": 1824, "nnz": 39208} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Boeing_nasa2910 (level: level1_small)\nShape: 2910 x 2910\nNon-zeros: 174296 (avg nnz/row ≈ 59.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Boeing_nasa2910.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Boeing_nasa2910", "num_rows": 2910, "num_cols": 2910, "nnz": 174296} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: CPM_cz1268 (level: level1_small)\nShape: 1268 x 1268\nNon-zeros: 12786 (avg nnz/row ≈ 10.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/CPM_cz1268.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "CPM_cz1268", "num_rows": 1268, "num_cols": 1268, "nnz": 12786} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DRIVCAV_cavity05 (level: level1_small)\nShape: 1182 x 1182\nNon-zeros: 32747 (avg nnz/row ≈ 27.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/DRIVCAV_cavity05.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "DRIVCAV_cavity05", "num_rows": 1182, "num_cols": 1182, "nnz": 32747} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DRIVCAV_cavity10 (level: level1_small)\nShape: 2597 x 2597\nNon-zeros: 76367 (avg nnz/row ≈ 29.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/DRIVCAV_cavity10.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "DRIVCAV_cavity10", "num_rows": 2597, "num_cols": 2597, "nnz": 76367} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DRIVCAV_cavity14 (level: level1_small)\nShape: 2597 x 2597\nNon-zeros: 76367 (avg nnz/row ≈ 29.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/DRIVCAV_cavity14.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "DRIVCAV_cavity14", "num_rows": 2597, "num_cols": 2597, "nnz": 76367} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DRIVCAV_cavity15 (level: level1_small)\nShape: 2597 x 2597\nNon-zeros: 76367 (avg nnz/row ≈ 29.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/DRIVCAV_cavity15.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "DRIVCAV_cavity15", "num_rows": 2597, "num_cols": 2597, "nnz": 76367} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Dattorro_EternityII_A (level: level1_small)\nShape: 7362 x 1\nNon-zeros: 358 (avg nnz/row ≈ 0.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Dattorro_EternityII_A.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Dattorro_EternityII_A", "num_rows": 7362, "num_cols": 1, "nnz": 358} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Dattorro_EternityII_Etilde (level: level1_small)\nShape: 10054 x 1\nNon-zeros: 512 (avg nnz/row ≈ 0.1)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Dattorro_EternityII_Etilde.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Dattorro_EternityII_Etilde", "num_rows": 10054, "num_cols": 1, "nnz": 512} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FIDAP_ex20 (level: level1_small)\nShape: 2203 x 2203\nNon-zeros: 69981 (avg nnz/row ≈ 31.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/FIDAP_ex20.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "FIDAP_ex20", "num_rows": 2203, "num_cols": 2203, "nnz": 69981} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FIDAP_ex23 (level: level1_small)\nShape: 1409 x 1409\nNon-zeros: 43703 (avg nnz/row ≈ 31.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/FIDAP_ex23.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "FIDAP_ex23", "num_rows": 1409, "num_cols": 1409, "nnz": 43703} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FIDAP_ex24 (level: level1_small)\nShape: 2283 x 2283\nNon-zeros: 48737 (avg nnz/row ≈ 21.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/FIDAP_ex24.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "FIDAP_ex24", "num_rows": 2283, "num_cols": 2283, "nnz": 48737} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FIDAP_ex36 (level: level1_small)\nShape: 3079 x 3079\nNon-zeros: 53843 (avg nnz/row ≈ 17.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/FIDAP_ex36.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "FIDAP_ex36", "num_rows": 3079, "num_cols": 3079, "nnz": 53843} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FIDAP_ex4 (level: level1_small)\nShape: 1601 x 1601\nNon-zeros: 32299 (avg nnz/row ≈ 20.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/FIDAP_ex4.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "FIDAP_ex4", "num_rows": 1601, "num_cols": 1601, "nnz": 32299} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FIDAP_ex7 (level: level1_small)\nShape: 1633 x 1633\nNon-zeros: 54543 (avg nnz/row ≈ 33.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/FIDAP_ex7.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "FIDAP_ex7", "num_rows": 1633, "num_cols": 1633, "nnz": 54543} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Goodwin_Goodwin_010 (level: level1_small)\nShape: 1182 x 1182\nNon-zeros: 32282 (avg nnz/row ≈ 27.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Goodwin_Goodwin_010.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Goodwin_Goodwin_010", "num_rows": 1182, "num_cols": 1182, "nnz": 32282} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Grund_bayer08 (level: level1_small)\nShape: 3008 x 3008\nNon-zeros: 27576 (avg nnz/row ≈ 9.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Grund_bayer08.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Grund_bayer08", "num_rows": 3008, "num_cols": 3008, "nnz": 27576} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Grund_bayer09 (level: level1_small)\nShape: 3083 x 3083\nNon-zeros: 21216 (avg nnz/row ≈ 6.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Grund_bayer09.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Grund_bayer09", "num_rows": 3083, "num_cols": 3083, "nnz": 21216} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Grund_meg1 (level: level1_small)\nShape: 2904 x 2904\nNon-zeros: 58142 (avg nnz/row ≈ 20.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Grund_meg1.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Grund_meg1", "num_rows": 2904, "num_cols": 2904, "nnz": 58142} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gset_G29 (level: level1_small)\nShape: 2000 x 2000\nNon-zeros: 39980 (avg nnz/row ≈ 20.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Gset_G29.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Gset_G29", "num_rows": 2000, "num_cols": 2000, "nnz": 39980} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gset_G39 (level: level1_small)\nShape: 2000 x 2000\nNon-zeros: 23556 (avg nnz/row ≈ 11.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Gset_G39.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Gset_G39", "num_rows": 2000, "num_cols": 2000, "nnz": 23556} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gset_G5 (level: level1_small)\nShape: 800 x 800\nNon-zeros: 38352 (avg nnz/row ≈ 47.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Gset_G5.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Gset_G5", "num_rows": 800, "num_cols": 800, "nnz": 38352} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gset_G54 (level: level1_small)\nShape: 1000 x 1000\nNon-zeros: 11832 (avg nnz/row ≈ 11.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Gset_G54.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Gset_G54", "num_rows": 1000, "num_cols": 1000, "nnz": 11832} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_bcsstk12 (level: level1_small)\nShape: 1473 x 1473\nNon-zeros: 34241 (avg nnz/row ≈ 23.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_bcsstk12.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_bcsstk12", "num_rows": 1473, "num_cols": 1473, "nnz": 34241} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_bcsstk13 (level: level1_small)\nShape: 2003 x 2003\nNon-zeros: 83883 (avg nnz/row ≈ 41.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_bcsstk13.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_bcsstk13", "num_rows": 2003, "num_cols": 2003, "nnz": 83883} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_bcsstm10 (level: level1_small)\nShape: 1086 x 1086\nNon-zeros: 22092 (avg nnz/row ≈ 20.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_bcsstm10.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_bcsstm10", "num_rows": 1086, "num_cols": 1086, "nnz": 22092} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_bcsstm13 (level: level1_small)\nShape: 2003 x 2003\nNon-zeros: 21943 (avg nnz/row ≈ 11.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_bcsstm13.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_bcsstm13", "num_rows": 2003, "num_cols": 2003, "nnz": 21943} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_cegb2802 (level: level1_small)\nShape: 2802 x 2802\nNon-zeros: 277362 (avg nnz/row ≈ 99.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_cegb2802.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_cegb2802", "num_rows": 2802, "num_cols": 2802, "nnz": 277362} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_lock2232 (level: level1_small)\nShape: 2232 x 2232\nNon-zeros: 80352 (avg nnz/row ≈ 36.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_lock2232.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_lock2232", "num_rows": 2232, "num_cols": 2232, "nnz": 80352} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_lshp1561 (level: level1_small)\nShape: 1561 x 1561\nNon-zeros: 10681 (avg nnz/row ≈ 6.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_lshp1561.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_lshp1561", "num_rows": 1561, "num_cols": 1561, "nnz": 10681} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_mbeause (level: level1_small)\nShape: 496 x 496\nNon-zeros: 41063 (avg nnz/row ≈ 82.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_mbeause.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_mbeause", "num_rows": 496, "num_cols": 496, "nnz": 41063} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_orani678 (level: level1_small)\nShape: 2529 x 2529\nNon-zeros: 90158 (avg nnz/row ≈ 35.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_orani678.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_orani678", "num_rows": 2529, "num_cols": 2529, "nnz": 90158} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_psmigr_1 (level: level1_small)\nShape: 3140 x 3140\nNon-zeros: 543162 (avg nnz/row ≈ 173.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_psmigr_1.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_psmigr_1", "num_rows": 3140, "num_cols": 3140, "nnz": 543162} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_psmigr_2 (level: level1_small)\nShape: 3140 x 3140\nNon-zeros: 540022 (avg nnz/row ≈ 172.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_psmigr_2.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_psmigr_2", "num_rows": 3140, "num_cols": 3140, "nnz": 540022} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_psmigr_3 (level: level1_small)\nShape: 3140 x 3140\nNon-zeros: 543162 (avg nnz/row ≈ 173.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/HB_psmigr_3.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "HB_psmigr_3", "num_rows": 3140, "num_cols": 3140, "nnz": 543162} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_CAG_CAG_mat1916 (level: level1_small)\nShape: 1916 x 1916\nNon-zeros: 195985 (avg nnz/row ≈ 102.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_CAG_CAG_mat1916.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_CAG_CAG_mat1916", "num_rows": 1916, "num_cols": 1916, "nnz": 195985} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_CAG_CAG_mat364 (level: level1_small)\nShape: 364 x 364\nNon-zeros: 13585 (avg nnz/row ≈ 37.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_CAG_CAG_mat364.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_CAG_CAG_mat364", "num_rows": 364, "num_cols": 364, "nnz": 13585} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Forest_TF14 (level: level1_small)\nShape: 2644 x 3160\nNon-zeros: 29862 (avg nnz/row ≈ 11.3)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_Forest_TF14.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_Forest_TF14", "num_rows": 2644, "num_cols": 3160, "nnz": 29862} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Groebner_HFE18_96_in (level: level1_small)\nShape: 2372 x 4096\nNon-zeros: 933343 (avg nnz/row ≈ 393.5)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_Groebner_HFE18_96_in.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_Groebner_HFE18_96_in", "num_rows": 2372, "num_cols": 4096, "nnz": 933343} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Groebner_f855_mat9 (level: level1_small)\nShape: 2456 x 2511\nNon-zeros: 171214 (avg nnz/row ≈ 69.7)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_Groebner_f855_mat9.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_Groebner_f855_mat9", "num_rows": 2456, "num_cols": 2511, "nnz": 171214} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Groebner_f855_mat9_I (level: level1_small)\nShape: 2456 x 2511\nNon-zeros: 171214 (avg nnz/row ≈ 69.7)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_Groebner_f855_mat9_I.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_Groebner_f855_mat9_I", "num_rows": 2456, "num_cols": 2511, "nnz": 171214} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Groebner_robot24c1_mat5_J (level: level1_small)\nShape: 302 x 404\nNon-zeros: 15118 (avg nnz/row ≈ 50.1)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_Groebner_robot24c1_mat5_J.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_Groebner_robot24c1_mat5_J", "num_rows": 302, "num_cols": 404, "nnz": 15118} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Kocay_Trec13 (level: level1_small)\nShape: 1301 x 6561\nNon-zeros: 654517 (avg nnz/row ≈ 503.1)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_Kocay_Trec13.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_Kocay_Trec13", "num_rows": 1301, "num_cols": 6561, "nnz": 654517} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_SL6_D_7 (level: level1_small)\nShape: 1270 x 971\nNon-zeros: 12714 (avg nnz/row ≈ 10.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_SL6_D_7.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_SL6_D_7", "num_rows": 1270, "num_cols": 971, "nnz": 12714} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_SPG_EX3 (level: level1_small)\nShape: 2600 x 2600\nNon-zeros: 71760 (avg nnz/row ≈ 27.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_SPG_EX3.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_SPG_EX3", "num_rows": 2600, "num_cols": 2600, "nnz": 71760} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Taha_abtaha1 (level: level1_small)\nShape: 14596 x 209\nNon-zeros: 51307 (avg nnz/row ≈ 3.5)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_Taha_abtaha1.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_Taha_abtaha1", "num_rows": 14596, "num_cols": 209, "nnz": 51307} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Trefethen_Trefethen_2000 (level: level1_small)\nShape: 2000 x 2000\nNon-zeros: 41906 (avg nnz/row ≈ 21.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_Trefethen_Trefethen_2000.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_Trefethen_Trefethen_2000", "num_rows": 2000, "num_cols": 2000, "nnz": 41906} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Trefethen_Trefethen_700 (level: level1_small)\nShape: 700 x 700\nNon-zeros: 12654 (avg nnz/row ≈ 18.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/JGD_Trefethen_Trefethen_700.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "JGD_Trefethen_Trefethen_700", "num_rows": 700, "num_cols": 700, "nnz": 12654} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: LeGresley_LeGresley_2508 (level: level1_small)\nShape: 2508 x 2508\nNon-zeros: 16727 (avg nnz/row ≈ 6.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/LeGresley_LeGresley_2508.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "LeGresley_LeGresley_2508", "num_rows": 2508, "num_cols": 2508, "nnz": 16727} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ML_Graph_YaleB_10NN (level: level1_small)\nShape: 2414 x 2414\nNon-zeros: 34808 (avg nnz/row ≈ 14.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/ML_Graph_YaleB_10NN.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "ML_Graph_YaleB_10NN", "num_rows": 2414, "num_cols": 2414, "nnz": 34808} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ML_Graph_dataset20mfeatpixel_10NN (level: level1_small)\nShape: 2000 x 2000\nNon-zeros: 27932 (avg nnz/row ≈ 14.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/ML_Graph_dataset20mfeatpixel_10NN.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "ML_Graph_dataset20mfeatpixel_10NN", "num_rows": 2000, "num_cols": 2000, "nnz": 27932} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ML_Graph_yeast_30NN (level: level1_small)\nShape: 1484 x 1484\nNon-zeros: 62350 (avg nnz/row ≈ 42.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/ML_Graph_yeast_30NN.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "ML_Graph_yeast_30NN", "num_rows": 1484, "num_cols": 1484, "nnz": 62350} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr02 (level: level1_small)\nShape: 2954 x 2954\nNon-zeros: 37206 (avg nnz/row ≈ 12.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Mallya_lhr02.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Mallya_lhr02", "num_rows": 2954, "num_cols": 2954, "nnz": 37206} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: MathWorks_TS (level: level1_small)\nShape: 2142 x 2142\nNon-zeros: 45262 (avg nnz/row ≈ 21.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/MathWorks_TS.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "MathWorks_TS", "num_rows": 2142, "num_cols": 2142, "nnz": 45262} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: MathWorks_tomography (level: level1_small)\nShape: 500 x 500\nNon-zeros: 28726 (avg nnz/row ≈ 57.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/MathWorks_tomography.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "MathWorks_tomography", "num_rows": 500, "num_cols": 500, "nnz": 28726} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_aa5 (level: level1_small)\nShape: 801 x 8308\nNon-zeros: 65953 (avg nnz/row ≈ 82.3)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Meszaros_aa5.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Meszaros_aa5", "num_rows": 801, "num_cols": 8308, "nnz": 65953} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Moqri_MISKnowledgeMap (level: level1_small)\nShape: 2427 x 2427\nNon-zeros: 57022 (avg nnz/row ≈ 23.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Moqri_MISKnowledgeMap.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Moqri_MISKnowledgeMap", "num_rows": 2427, "num_cols": 2427, "nnz": 57022} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Morandini_rotor2 (level: level1_small)\nShape: 791 x 791\nNon-zeros: 10685 (avg nnz/row ≈ 13.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Morandini_rotor2.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Morandini_rotor2", "num_rows": 791, "num_cols": 791, "nnz": 10685} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mycielski_mycielskian11 (level: level1_small)\nShape: 1535 x 1535\nNon-zeros: 134710 (avg nnz/row ≈ 87.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Mycielski_mycielskian11.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Mycielski_mycielskian11", "num_rows": 1535, "num_cols": 1535, "nnz": 134710} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mycielski_mycielskian12 (level: level1_small)\nShape: 3071 x 3071\nNon-zeros: 407200 (avg nnz/row ≈ 132.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Mycielski_mycielskian12.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Mycielski_mycielskian12", "num_rows": 3071, "num_cols": 3071, "nnz": 407200} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mycielski_mycielskian9 (level: level1_small)\nShape: 383 x 383\nNon-zeros: 14542 (avg nnz/row ≈ 38.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Mycielski_mycielskian9.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Mycielski_mycielskian9", "num_rows": 383, "num_cols": 383, "nnz": 14542} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Negre_dendrimer (level: level1_small)\nShape: 730 x 730\nNon-zeros: 63024 (avg nnz/row ≈ 86.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Negre_dendrimer.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Negre_dendrimer", "num_rows": 730, "num_cols": 730, "nnz": 63024} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Newman_polblogs (level: level1_small)\nShape: 1490 x 1490\nNon-zeros: 19025 (avg nnz/row ≈ 12.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Newman_polblogs.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Newman_polblogs", "num_rows": 1490, "num_cols": 1490, "nnz": 19025} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Norris_heart2 (level: level1_small)\nShape: 2339 x 2339\nNon-zeros: 682797 (avg nnz/row ≈ 291.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Norris_heart2.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Norris_heart2", "num_rows": 2339, "num_cols": 2339, "nnz": 682797} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Norris_heart3 (level: level1_small)\nShape: 2339 x 2339\nNon-zeros: 682797 (avg nnz/row ≈ 291.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Norris_heart3.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Norris_heart3", "num_rows": 2339, "num_cols": 2339, "nnz": 682797} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_piston (level: level1_small)\nShape: 2025 x 2025\nNon-zeros: 100015 (avg nnz/row ≈ 49.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Oberwolfach_piston.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Oberwolfach_piston", "num_rows": 2025, "num_cols": 2025, "nnz": 100015} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_spiral (level: level1_small)\nShape: 1434 x 1434\nNon-zeros: 18228 (avg nnz/row ≈ 12.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Oberwolfach_spiral.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Oberwolfach_spiral", "num_rows": 1434, "num_cols": 1434, "nnz": 18228} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: QCD_conf5_0-4x4-26 (level: level1_small)\nShape: 3072 x 3072\nNon-zeros: 119808 (avg nnz/row ≈ 39.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/QCD_conf5_0-4x4-26.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "QCD_conf5_0-4x4-26", "num_rows": 3072, "num_cols": 3072, "nnz": 119808} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_CollegeMsg (level: level1_small)\nShape: 1899 x 1899\nNon-zeros: 20296 (avg nnz/row ≈ 10.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/SNAP_CollegeMsg.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "SNAP_CollegeMsg", "num_rows": 1899, "num_cols": 1899, "nnz": 20296} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_email-Eu-core-temporal (level: level1_small)\nShape: 1005 x 1005\nNon-zeros: 24929 (avg nnz/row ≈ 24.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/SNAP_email-Eu-core-temporal.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "SNAP_email-Eu-core-temporal", "num_rows": 1005, "num_cols": 1005, "nnz": 24929} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_email-Eu-core (level: level1_small)\nShape: 1005 x 1005\nNon-zeros: 25571 (avg nnz/row ≈ 25.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/SNAP_email-Eu-core.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "SNAP_email-Eu-core", "num_rows": 1005, "num_cols": 1005, "nnz": 25571} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Sandia_adder_dcop_03 (level: level1_small)\nShape: 1813 x 1813\nNon-zeros: 11148 (avg nnz/row ≈ 6.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Sandia_adder_dcop_03.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Sandia_adder_dcop_03", "num_rows": 1813, "num_cols": 1813, "nnz": 11148} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Sandia_adder_dcop_18 (level: level1_small)\nShape: 1813 x 1813\nNon-zeros: 11246 (avg nnz/row ≈ 6.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Sandia_adder_dcop_18.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Sandia_adder_dcop_18", "num_rows": 1813, "num_cols": 1813, "nnz": 11246} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Sandia_adder_dcop_31 (level: level1_small)\nShape: 1813 x 1813\nNon-zeros: 11246 (avg nnz/row ≈ 6.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Sandia_adder_dcop_31.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Sandia_adder_dcop_31", "num_rows": 1813, "num_cols": 1813, "nnz": 11246} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Sandia_adder_dcop_37 (level: level1_small)\nShape: 1813 x 1813\nNon-zeros: 11246 (avg nnz/row ≈ 6.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Sandia_adder_dcop_37.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Sandia_adder_dcop_37", "num_rows": 1813, "num_cols": 1813, "nnz": 11246} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Sandia_adder_dcop_64 (level: level1_small)\nShape: 1813 x 1813\nNon-zeros: 11246 (avg nnz/row ≈ 6.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Sandia_adder_dcop_64.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Sandia_adder_dcop_64", "num_rows": 1813, "num_cols": 1813, "nnz": 11246} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Sandia_adder_trans_01 (level: level1_small)\nShape: 1814 x 1814\nNon-zeros: 14579 (avg nnz/row ≈ 8.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Sandia_adder_trans_01.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Sandia_adder_trans_01", "num_rows": 1814, "num_cols": 1814, "nnz": 14579} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TOKAMAK_utm1700b (level: level1_small)\nShape: 1700 x 1700\nNon-zeros: 21509 (avg nnz/row ≈ 12.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/TOKAMAK_utm1700b.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "TOKAMAK_utm1700b", "num_rows": 1700, "num_cols": 1700, "nnz": 21509} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TOKAMAK_utm3060 (level: level1_small)\nShape: 3060 x 3060\nNon-zeros: 42211 (avg nnz/row ≈ 13.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/TOKAMAK_utm3060.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "TOKAMAK_utm3060", "num_rows": 3060, "num_cols": 3060, "nnz": 42211} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b300_c3 (level: level1_small)\nShape: 42138 x 137\nNon-zeros: 21109 (avg nnz/row ≈ 0.5)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/TSOPF_TSOPF_RS_b300_c3.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "TSOPF_TSOPF_RS_b300_c3", "num_rows": 42138, "num_cols": 137, "nnz": 21109} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b39_c19 (level: level1_small)\nShape: 38098 x 19\nNon-zeros: 19053 (avg nnz/row ≈ 0.5)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/TSOPF_TSOPF_RS_b39_c19.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "TSOPF_TSOPF_RS_b39_c19", "num_rows": 38098, "num_cols": 19, "nnz": 19053} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b39_c7 (level: level1_small)\nShape: 14098 x 19\nNon-zeros: 7053 (avg nnz/row ≈ 0.5)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/TSOPF_TSOPF_RS_b39_c7.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "TSOPF_TSOPF_RS_b39_c7", "num_rows": 14098, "num_cols": 19, "nnz": 7053} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VDOL_hangGlider_2 (level: level1_small)\nShape: 1647 x 1647\nNon-zeros: 14754 (avg nnz/row ≈ 9.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/VDOL_hangGlider_2.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "VDOL_hangGlider_2", "num_rows": 1647, "num_cols": 1647, "nnz": 14754} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VDOL_spaceShuttleEntry_4 (level: level1_small)\nShape: 2450 x 2450\nNon-zeros: 39669 (avg nnz/row ≈ 16.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/VDOL_spaceShuttleEntry_4.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "VDOL_spaceShuttleEntry_4", "num_rows": 2450, "num_cols": 2450, "nnz": 39669} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VDOL_spaceStation_6 (level: level1_small)\nShape: 1111 x 1111\nNon-zeros: 17595 (avg nnz/row ≈ 15.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/VDOL_spaceStation_6.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "VDOL_spaceStation_6", "num_rows": 1111, "num_cols": 1111, "nnz": 17595} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Wang_wang1 (level: level1_small)\nShape: 2903 x 2903\nNon-zeros: 19093 (avg nnz/row ≈ 6.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Wang_wang1.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Wang_wang1", "num_rows": 2903, "num_cols": 2903, "nnz": 19093} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Zitney_extr1 (level: level1_small)\nShape: 2837 x 2837\nNon-zeros: 11407 (avg nnz/row ≈ 4.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Zitney_extr1.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Zitney_extr1", "num_rows": 2837, "num_cols": 2837, "nnz": 11407} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Zitney_rdist3a (level: level1_small)\nShape: 2398 x 2398\nNon-zeros: 61896 (avg nnz/row ≈ 25.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level1_small/Zitney_rdist3a.bin", "op_type": "spgemm", "K": 0, "level": "level1_small", "matrix_name": "Zitney_rdist3a", "num_rows": 2398, "num_cols": 2398, "nnz": 61896} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ACUSIM_Pres_Poisson (level: level2_medium)\nShape: 14822 x 14822\nNon-zeros: 715804 (avg nnz/row ≈ 48.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/ACUSIM_Pres_Poisson.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "ACUSIM_Pres_Poisson", "num_rows": 14822, "num_cols": 14822, "nnz": 715804} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: AG-Monien_ukerbe1 (level: level2_medium)\nShape: 5981 x 5981\nNon-zeros: 15704 (avg nnz/row ≈ 2.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/AG-Monien_ukerbe1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "AG-Monien_ukerbe1", "num_rows": 5981, "num_cols": 5981, "nnz": 15704} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Andrianov_ex3sta1 (level: level2_medium)\nShape: 16782 x 16782\nNon-zeros: 678998 (avg nnz/row ≈ 40.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Andrianov_ex3sta1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Andrianov_ex3sta1", "num_rows": 16782, "num_cols": 16782, "nnz": 678998} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Andrianov_fxm4_6 (level: level2_medium)\nShape: 18892 x 18892\nNon-zeros: 497844 (avg nnz/row ≈ 26.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Andrianov_fxm4_6.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Andrianov_fxm4_6", "num_rows": 18892, "num_cols": 18892, "nnz": 497844} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Andrianov_net100 (level: level2_medium)\nShape: 29920 x 29920\nNon-zeros: 2033200 (avg nnz/row ≈ 68.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Andrianov_net100.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Andrianov_net100", "num_rows": 29920, "num_cols": 29920, "nnz": 2033200} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Andrianov_net25 (level: level2_medium)\nShape: 9520 x 9520\nNon-zeros: 401200 (avg nnz/row ≈ 42.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Andrianov_net25.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Andrianov_net25", "num_rows": 9520, "num_cols": 9520, "nnz": 401200} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Andrianov_net50 (level: level2_medium)\nShape: 16320 x 16320\nNon-zeros: 945200 (avg nnz/row ≈ 57.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Andrianov_net50.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Andrianov_net50", "num_rows": 16320, "num_cols": 16320, "nnz": 945200} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Andrianov_net75 (level: level2_medium)\nShape: 23120 x 23120\nNon-zeros: 1489200 (avg nnz/row ≈ 64.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Andrianov_net75.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Andrianov_net75", "num_rows": 23120, "num_cols": 23120, "nnz": 1489200} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Andrianov_pf2177 (level: level2_medium)\nShape: 9728 x 9728\nNon-zeros: 725144 (avg nnz/row ≈ 74.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Andrianov_pf2177.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Andrianov_pf2177", "num_rows": 9728, "num_cols": 9728, "nnz": 725144} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Arenas_PGPgiantcompo (level: level2_medium)\nShape: 10680 x 10680\nNon-zeros: 48632 (avg nnz/row ≈ 4.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Arenas_PGPgiantcompo.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Arenas_PGPgiantcompo", "num_rows": 10680, "num_cols": 10680, "nnz": 48632} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bai_af23560 (level: level2_medium)\nShape: 23560 x 23560\nNon-zeros: 484256 (avg nnz/row ≈ 20.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bai_af23560.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bai_af23560", "num_rows": 23560, "num_cols": 23560, "nnz": 484256} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bai_dw4096 (level: level2_medium)\nShape: 8192 x 8192\nNon-zeros: 41746 (avg nnz/row ≈ 5.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bai_dw4096.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bai_dw4096", "num_rows": 8192, "num_cols": 8192, "nnz": 41746} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bai_mhd3200a (level: level2_medium)\nShape: 3200 x 3200\nNon-zeros: 68026 (avg nnz/row ≈ 21.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bai_mhd3200a.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bai_mhd3200a", "num_rows": 3200, "num_cols": 3200, "nnz": 68026} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bai_mhd4800a (level: level2_medium)\nShape: 4800 x 4800\nNon-zeros: 102252 (avg nnz/row ≈ 21.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bai_mhd4800a.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bai_mhd4800a", "num_rows": 4800, "num_cols": 4800, "nnz": 102252} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bai_rw5151 (level: level2_medium)\nShape: 5151 x 5151\nNon-zeros: 20199 (avg nnz/row ≈ 3.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bai_rw5151.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bai_rw5151", "num_rows": 5151, "num_cols": 5151, "nnz": 20199} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bates_Chem97Zt (level: level2_medium)\nShape: 2541 x 31022\nNon-zeros: 62044 (avg nnz/row ≈ 24.4)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bates_Chem97Zt.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bates_Chem97Zt", "num_rows": 2541, "num_cols": 31022, "nnz": 62044} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bindel_ted_A (level: level2_medium)\nShape: 10605 x 10605\nNon-zeros: 424587 (avg nnz/row ≈ 40.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bindel_ted_A.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bindel_ted_A", "num_rows": 10605, "num_cols": 10605, "nnz": 424587} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bindel_ted_A_unscaled (level: level2_medium)\nShape: 10605 x 10605\nNon-zeros: 424587 (avg nnz/row ≈ 40.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bindel_ted_A_unscaled.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bindel_ted_A_unscaled", "num_rows": 10605, "num_cols": 10605, "nnz": 424587} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bindel_ted_B (level: level2_medium)\nShape: 10605 x 10605\nNon-zeros: 144579 (avg nnz/row ≈ 13.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bindel_ted_B.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bindel_ted_B", "num_rows": 10605, "num_cols": 10605, "nnz": 144579} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bindel_ted_B_unscaled (level: level2_medium)\nShape: 10605 x 10605\nNon-zeros: 144579 (avg nnz/row ≈ 13.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bindel_ted_B_unscaled.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bindel_ted_B_unscaled", "num_rows": 10605, "num_cols": 10605, "nnz": 144579} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bodendiek_CurlCurl_0 (level: level2_medium)\nShape: 11083 x 11083\nNon-zeros: 113343 (avg nnz/row ≈ 10.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bodendiek_CurlCurl_0.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bodendiek_CurlCurl_0", "num_rows": 11083, "num_cols": 11083, "nnz": 113343} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Boeing_bcsstk38 (level: level2_medium)\nShape: 8032 x 8032\nNon-zeros: 355460 (avg nnz/row ≈ 44.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Boeing_bcsstk38.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Boeing_bcsstk38", "num_rows": 8032, "num_cols": 8032, "nnz": 355460} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Boeing_crystk01 (level: level2_medium)\nShape: 4875 x 4875\nNon-zeros: 315891 (avg nnz/row ≈ 64.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Boeing_crystk01.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Boeing_crystk01", "num_rows": 4875, "num_cols": 4875, "nnz": 315891} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Boeing_crystk02 (level: level2_medium)\nShape: 13965 x 13965\nNon-zeros: 968583 (avg nnz/row ≈ 69.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Boeing_crystk02.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Boeing_crystk02", "num_rows": 13965, "num_cols": 13965, "nnz": 968583} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Boeing_crystk03 (level: level2_medium)\nShape: 24696 x 24696\nNon-zeros: 1751178 (avg nnz/row ≈ 70.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Boeing_crystk03.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Boeing_crystk03", "num_rows": 24696, "num_cols": 24696, "nnz": 1751178} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Boeing_crystm01 (level: level2_medium)\nShape: 4875 x 4875\nNon-zeros: 105339 (avg nnz/row ≈ 21.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Boeing_crystm01.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Boeing_crystm01", "num_rows": 4875, "num_cols": 4875, "nnz": 105339} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Boeing_crystm02 (level: level2_medium)\nShape: 13965 x 13965\nNon-zeros: 322905 (avg nnz/row ≈ 23.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Boeing_crystm02.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Boeing_crystm02", "num_rows": 13965, "num_cols": 13965, "nnz": 322905} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Boeing_nasa4704 (level: level2_medium)\nShape: 4704 x 4704\nNon-zeros: 104756 (avg nnz/row ≈ 22.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Boeing_nasa4704.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Boeing_nasa4704", "num_rows": 4704, "num_cols": 4704, "nnz": 104756} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Boeing_pcrystk02 (level: level2_medium)\nShape: 13965 x 13965\nNon-zeros: 968583 (avg nnz/row ≈ 69.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Boeing_pcrystk02.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Boeing_pcrystk02", "num_rows": 13965, "num_cols": 13965, "nnz": 968583} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bomhof_circuit_2 (level: level2_medium)\nShape: 4510 x 4510\nNon-zeros: 21199 (avg nnz/row ≈ 4.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bomhof_circuit_2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bomhof_circuit_2", "num_rows": 4510, "num_cols": 4510, "nnz": 21199} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bomhof_circuit_3 (level: level2_medium)\nShape: 12127 x 12127\nNon-zeros: 48137 (avg nnz/row ≈ 4.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Bomhof_circuit_3.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Bomhof_circuit_3", "num_rows": 12127, "num_cols": 12127, "nnz": 48137} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Botonakis_FEM_3D_thermal1 (level: level2_medium)\nShape: 17880 x 17880\nNon-zeros: 430740 (avg nnz/row ≈ 24.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Botonakis_FEM_3D_thermal1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Botonakis_FEM_3D_thermal1", "num_rows": 17880, "num_cols": 17880, "nnz": 430740} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Brethour_coater2 (level: level2_medium)\nShape: 9540 x 9540\nNon-zeros: 207308 (avg nnz/row ≈ 21.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Brethour_coater2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Brethour_coater2", "num_rows": 9540, "num_cols": 9540, "nnz": 207308} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: CPM_cz5108 (level: level2_medium)\nShape: 5108 x 5108\nNon-zeros: 51412 (avg nnz/row ≈ 10.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/CPM_cz5108.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "CPM_cz5108", "num_rows": 5108, "num_cols": 5108, "nnz": 51412} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Cannizzo_sts4098 (level: level2_medium)\nShape: 4098 x 4098\nNon-zeros: 72356 (avg nnz/row ≈ 17.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Cannizzo_sts4098.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Cannizzo_sts4098", "num_rows": 4098, "num_cols": 4098, "nnz": 72356} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Chen_pkustk02 (level: level2_medium)\nShape: 10800 x 10800\nNon-zeros: 810000 (avg nnz/row ≈ 75.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Chen_pkustk02.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Chen_pkustk02", "num_rows": 10800, "num_cols": 10800, "nnz": 810000} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Cote_mplate (level: level2_medium)\nShape: 5962 x 5962\nNon-zeros: 142190 (avg nnz/row ≈ 23.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Cote_mplate.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Cote_mplate", "num_rows": 5962, "num_cols": 5962, "nnz": 142190} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Cote_vibrobox (level: level2_medium)\nShape: 12328 x 12328\nNon-zeros: 342828 (avg nnz/row ≈ 27.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Cote_vibrobox.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Cote_vibrobox", "num_rows": 12328, "num_cols": 12328, "nnz": 342828} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Cunningham_k3plates (level: level2_medium)\nShape: 11107 x 11107\nNon-zeros: 378927 (avg nnz/row ≈ 34.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Cunningham_k3plates.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Cunningham_k3plates", "num_rows": 11107, "num_cols": 11107, "nnz": 378927} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Cylshell_s3rmq4m1 (level: level2_medium)\nShape: 5489 x 5489\nNon-zeros: 281111 (avg nnz/row ≈ 51.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Cylshell_s3rmq4m1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Cylshell_s3rmq4m1", "num_rows": 5489, "num_cols": 5489, "nnz": 281111} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_vsp_c-30_data_data (level: level2_medium)\nShape: 11023 x 11023\nNon-zeros: 124368 (avg nnz/row ≈ 11.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/DIMACS10_vsp_c-30_data_data.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "DIMACS10_vsp_c-30_data_data", "num_rows": 11023, "num_cols": 11023, "nnz": 124368} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_vsp_data_and_seymourl (level: level2_medium)\nShape: 9167 x 9167\nNon-zeros: 111732 (avg nnz/row ≈ 12.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/DIMACS10_vsp_data_and_seymourl.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "DIMACS10_vsp_data_and_seymourl", "num_rows": 9167, "num_cols": 9167, "nnz": 111732} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_wing_nodal (level: level2_medium)\nShape: 10937 x 10937\nNon-zeros: 150976 (avg nnz/row ≈ 13.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/DIMACS10_wing_nodal.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "DIMACS10_wing_nodal", "num_rows": 10937, "num_cols": 10937, "nnz": 150976} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DNVS_trdheim (level: level2_medium)\nShape: 22098 x 22098\nNon-zeros: 1935324 (avg nnz/row ≈ 87.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/DNVS_trdheim.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "DNVS_trdheim", "num_rows": 22098, "num_cols": 22098, "nnz": 1935324} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DNVS_tsyl201 (level: level2_medium)\nShape: 20685 x 20685\nNon-zeros: 2454957 (avg nnz/row ≈ 118.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/DNVS_tsyl201.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "DNVS_tsyl201", "num_rows": 20685, "num_cols": 20685, "nnz": 2454957} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DRIVCAV_cavity17 (level: level2_medium)\nShape: 4562 x 4562\nNon-zeros: 138187 (avg nnz/row ≈ 30.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/DRIVCAV_cavity17.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "DRIVCAV_cavity17", "num_rows": 4562, "num_cols": 4562, "nnz": 138187} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DRIVCAV_cavity20 (level: level2_medium)\nShape: 4562 x 4562\nNon-zeros: 138187 (avg nnz/row ≈ 30.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/DRIVCAV_cavity20.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "DRIVCAV_cavity20", "num_rows": 4562, "num_cols": 4562, "nnz": 138187} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DRIVCAV_cavity21 (level: level2_medium)\nShape: 4562 x 4562\nNon-zeros: 138187 (avg nnz/row ≈ 30.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/DRIVCAV_cavity21.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "DRIVCAV_cavity21", "num_rows": 4562, "num_cols": 4562, "nnz": 138187} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DRIVCAV_cavity22 (level: level2_medium)\nShape: 4562 x 4562\nNon-zeros: 138187 (avg nnz/row ≈ 30.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/DRIVCAV_cavity22.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "DRIVCAV_cavity22", "num_rows": 4562, "num_cols": 4562, "nnz": 138187} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Davis_FX_March2010 (level: level2_medium)\nShape: 1319 x 9498\nNon-zeros: 301899 (avg nnz/row ≈ 228.9)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Davis_FX_March2010.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Davis_FX_March2010", "num_rows": 1319, "num_cols": 9498, "nnz": 301899} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FEMLAB_poisson3Da (level: level2_medium)\nShape: 13514 x 13514\nNon-zeros: 352762 (avg nnz/row ≈ 26.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/FEMLAB_poisson3Da.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "FEMLAB_poisson3Da", "num_rows": 13514, "num_cols": 13514, "nnz": 352762} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FIDAP_ex37 (level: level2_medium)\nShape: 3565 x 3565\nNon-zeros: 67591 (avg nnz/row ≈ 19.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/FIDAP_ex37.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "FIDAP_ex37", "num_rows": 3565, "num_cols": 3565, "nnz": 67591} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FIDAP_ex40 (level: level2_medium)\nShape: 7740 x 7740\nNon-zeros: 458012 (avg nnz/row ≈ 59.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/FIDAP_ex40.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "FIDAP_ex40", "num_rows": 7740, "num_cols": 7740, "nnz": 458012} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FIDAP_ex9 (level: level2_medium)\nShape: 3363 x 3363\nNon-zeros: 99471 (avg nnz/row ≈ 29.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/FIDAP_ex9.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "FIDAP_ex9", "num_rows": 3363, "num_cols": 3363, "nnz": 99471} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Fluorem_GT01R (level: level2_medium)\nShape: 7980 x 7980\nNon-zeros: 430909 (avg nnz/row ≈ 54.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Fluorem_GT01R.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Fluorem_GT01R", "num_rows": 7980, "num_cols": 7980, "nnz": 430909} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_bloweya (level: level2_medium)\nShape: 30004 x 30004\nNon-zeros: 150009 (avg nnz/row ≈ 5.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/GHS_indef_bloweya.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "GHS_indef_bloweya", "num_rows": 30004, "num_cols": 30004, "nnz": 150009} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_bloweybl (level: level2_medium)\nShape: 30003 x 30003\nNon-zeros: 120000 (avg nnz/row ≈ 4.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/GHS_indef_bloweybl.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "GHS_indef_bloweybl", "num_rows": 30003, "num_cols": 30003, "nnz": 120000} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_bratu3d (level: level2_medium)\nShape: 27792 x 27792\nNon-zeros: 173796 (avg nnz/row ≈ 6.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/GHS_indef_bratu3d.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "GHS_indef_bratu3d", "num_rows": 27792, "num_cols": 27792, "nnz": 173796} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_linverse (level: level2_medium)\nShape: 11999 x 11999\nNon-zeros: 95977 (avg nnz/row ≈ 8.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/GHS_indef_linverse.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "GHS_indef_linverse", "num_rows": 11999, "num_cols": 11999, "nnz": 95977} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_tuma1 (level: level2_medium)\nShape: 22967 x 22967\nNon-zeros: 87760 (avg nnz/row ≈ 3.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/GHS_indef_tuma1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "GHS_indef_tuma1", "num_rows": 22967, "num_cols": 22967, "nnz": 87760} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_tuma2 (level: level2_medium)\nShape: 12992 x 12992\nNon-zeros: 49365 (avg nnz/row ≈ 3.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/GHS_indef_tuma2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "GHS_indef_tuma2", "num_rows": 12992, "num_cols": 12992, "nnz": 49365} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_psdef_ramage02 (level: level2_medium)\nShape: 16830 x 16830\nNon-zeros: 2866352 (avg nnz/row ≈ 170.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/GHS_psdef_ramage02.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "GHS_psdef_ramage02", "num_rows": 16830, "num_cols": 16830, "nnz": 2866352} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_psdef_wathen100 (level: level2_medium)\nShape: 30401 x 30401\nNon-zeros: 471601 (avg nnz/row ≈ 15.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/GHS_psdef_wathen100.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "GHS_psdef_wathen100", "num_rows": 30401, "num_cols": 30401, "nnz": 471601} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gaertner_big (level: level2_medium)\nShape: 13209 x 13209\nNon-zeros: 91465 (avg nnz/row ≈ 6.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Gaertner_big.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Gaertner_big", "num_rows": 13209, "num_cols": 13209, "nnz": 91465} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gleich_wb-cs-stanford (level: level2_medium)\nShape: 9914 x 9914\nNon-zeros: 36854 (avg nnz/row ≈ 3.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Gleich_wb-cs-stanford.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Gleich_wb-cs-stanford", "num_rows": 9914, "num_cols": 9914, "nnz": 36854} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Goodwin_Goodwin_030 (level: level2_medium)\nShape: 10142 x 10142\nNon-zeros: 312814 (avg nnz/row ≈ 30.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Goodwin_Goodwin_030.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Goodwin_Goodwin_030", "num_rows": 10142, "num_cols": 10142, "nnz": 312814} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Goodwin_Goodwin_040 (level: level2_medium)\nShape: 17922 x 17922\nNon-zeros: 561677 (avg nnz/row ≈ 31.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Goodwin_Goodwin_040.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Goodwin_Goodwin_040", "num_rows": 17922, "num_cols": 17922, "nnz": 561677} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Goodwin_rim (level: level2_medium)\nShape: 22560 x 22560\nNon-zeros: 1014951 (avg nnz/row ≈ 45.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Goodwin_rim.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Goodwin_rim", "num_rows": 22560, "num_cols": 22560, "nnz": 1014951} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Graham_graham1 (level: level2_medium)\nShape: 9035 x 9035\nNon-zeros: 335504 (avg nnz/row ≈ 37.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Graham_graham1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Graham_graham1", "num_rows": 9035, "num_cols": 9035, "nnz": 335504} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Grueninger_windtunnel_evap2d (level: level2_medium)\nShape: 8256 x 8256\nNon-zeros: 233468 (avg nnz/row ≈ 28.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Grueninger_windtunnel_evap2d.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Grueninger_windtunnel_evap2d", "num_rows": 8256, "num_cols": 8256, "nnz": 233468} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Grund_poli3 (level: level2_medium)\nShape: 16955 x 16955\nNon-zeros: 37849 (avg nnz/row ≈ 2.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Grund_poli3.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Grund_poli3", "num_rows": 16955, "num_cols": 16955, "nnz": 37849} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gset_G56 (level: level2_medium)\nShape: 5000 x 5000\nNon-zeros: 24996 (avg nnz/row ≈ 5.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Gset_G56.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Gset_G56", "num_rows": 5000, "num_cols": 5000, "nnz": 24996} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gset_G58 (level: level2_medium)\nShape: 5000 x 5000\nNon-zeros: 59140 (avg nnz/row ≈ 11.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Gset_G58.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Gset_G58", "num_rows": 5000, "num_cols": 5000, "nnz": 59140} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gset_G60 (level: level2_medium)\nShape: 7000 x 7000\nNon-zeros: 34296 (avg nnz/row ≈ 4.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Gset_G60.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Gset_G60", "num_rows": 7000, "num_cols": 7000, "nnz": 34296} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gset_G61 (level: level2_medium)\nShape: 7000 x 7000\nNon-zeros: 34296 (avg nnz/row ≈ 4.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Gset_G61.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Gset_G61", "num_rows": 7000, "num_cols": 7000, "nnz": 34296} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gset_G63 (level: level2_medium)\nShape: 7000 x 7000\nNon-zeros: 82918 (avg nnz/row ≈ 11.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Gset_G63.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Gset_G63", "num_rows": 7000, "num_cols": 7000, "nnz": 82918} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gset_G64 (level: level2_medium)\nShape: 7000 x 7000\nNon-zeros: 82918 (avg nnz/row ≈ 11.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Gset_G64.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Gset_G64", "num_rows": 7000, "num_cols": 7000, "nnz": 82918} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gset_G66 (level: level2_medium)\nShape: 9000 x 9000\nNon-zeros: 36000 (avg nnz/row ≈ 4.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Gset_G66.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Gset_G66", "num_rows": 9000, "num_cols": 9000, "nnz": 36000} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Guettel_TEM27623 (level: level2_medium)\nShape: 27623 x 27623\nNon-zeros: 439469 (avg nnz/row ≈ 15.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Guettel_TEM27623.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Guettel_TEM27623", "num_rows": 27623, "num_cols": 27623, "nnz": 439469} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_bcsstk28 (level: level2_medium)\nShape: 4410 x 4410\nNon-zeros: 219024 (avg nnz/row ≈ 49.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/HB_bcsstk28.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "HB_bcsstk28", "num_rows": 4410, "num_cols": 4410, "nnz": 219024} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_bcsstk30 (level: level2_medium)\nShape: 28924 x 28924\nNon-zeros: 2043492 (avg nnz/row ≈ 70.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/HB_bcsstk30.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "HB_bcsstk30", "num_rows": 28924, "num_cols": 28924, "nnz": 2043492} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_gemat11 (level: level2_medium)\nShape: 4929 x 4929\nNon-zeros: 33185 (avg nnz/row ≈ 6.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/HB_gemat11.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "HB_gemat11", "num_rows": 4929, "num_cols": 4929, "nnz": 33185} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_gemat12 (level: level2_medium)\nShape: 4929 x 4929\nNon-zeros: 33111 (avg nnz/row ≈ 6.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/HB_gemat12.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "HB_gemat12", "num_rows": 4929, "num_cols": 4929, "nnz": 33111} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_lns_3937 (level: level2_medium)\nShape: 3937 x 3937\nNon-zeros: 25407 (avg nnz/row ≈ 6.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/HB_lns_3937.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "HB_lns_3937", "num_rows": 3937, "num_cols": 3937, "nnz": 25407} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_lock3491 (level: level2_medium)\nShape: 3491 x 3491\nNon-zeros: 160444 (avg nnz/row ≈ 46.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/HB_lock3491.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "HB_lock3491", "num_rows": 3491, "num_cols": 3491, "nnz": 160444} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_sherman3 (level: level2_medium)\nShape: 5005 x 5005\nNon-zeros: 20033 (avg nnz/row ≈ 4.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/HB_sherman3.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "HB_sherman3", "num_rows": 5005, "num_cols": 5005, "nnz": 20033} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: HB_sherman5 (level: level2_medium)\nShape: 3312 x 3312\nNon-zeros: 20793 (avg nnz/row ≈ 6.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/HB_sherman5.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "HB_sherman5", "num_rows": 3312, "num_cols": 3312, "nnz": 20793} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hohn_fd12 (level: level2_medium)\nShape: 7500 x 7500\nNon-zeros: 28462 (avg nnz/row ≈ 3.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Hohn_fd12.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Hohn_fd12", "num_rows": 7500, "num_cols": 7500, "nnz": 28462} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hohn_fd15 (level: level2_medium)\nShape: 11532 x 11532\nNon-zeros: 44206 (avg nnz/row ≈ 3.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Hohn_fd15.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Hohn_fd15", "num_rows": 11532, "num_cols": 11532, "nnz": 44206} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hohn_sinc15 (level: level2_medium)\nShape: 11532 x 11532\nNon-zeros: 568526 (avg nnz/row ≈ 49.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Hohn_sinc15.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Hohn_sinc15", "num_rows": 11532, "num_cols": 11532, "nnz": 568526} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hohn_sinc18 (level: level2_medium)\nShape: 16428 x 16428\nNon-zeros: 973826 (avg nnz/row ≈ 59.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Hohn_sinc18.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Hohn_sinc18", "num_rows": 16428, "num_cols": 16428, "nnz": 973826} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hollinger_g7jac100sc (level: level2_medium)\nShape: 29610 x 29610\nNon-zeros: 384636 (avg nnz/row ≈ 13.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Hollinger_g7jac100sc.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Hollinger_g7jac100sc", "num_rows": 29610, "num_cols": 29610, "nnz": 384636} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: IPSO_OPF_3754 (level: level2_medium)\nShape: 15435 x 15435\nNon-zeros: 158273 (avg nnz/row ≈ 10.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/IPSO_OPF_3754.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "IPSO_OPF_3754", "num_rows": 15435, "num_cols": 15435, "nnz": 158273} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: IPSO_OPF_6000 (level: level2_medium)\nShape: 29902 x 29902\nNon-zeros: 302418 (avg nnz/row ≈ 10.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/IPSO_OPF_6000.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "IPSO_OPF_6000", "num_rows": 29902, "num_cols": 29902, "nnz": 302418} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: IPSO_TSC_OPF_1047 (level: level2_medium)\nShape: 8140 x 8140\nNon-zeros: 2016902 (avg nnz/row ≈ 247.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/IPSO_TSC_OPF_1047.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "IPSO_TSC_OPF_1047", "num_rows": 8140, "num_cols": 8140, "nnz": 2016902} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: IPSO_TSC_OPF_300 (level: level2_medium)\nShape: 9774 x 9774\nNon-zeros: 820804 (avg nnz/row ≈ 84.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/IPSO_TSC_OPF_300.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "IPSO_TSC_OPF_300", "num_rows": 9774, "num_cols": 9774, "nnz": 820804} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Forest_TF16 (level: level2_medium)\nShape: 15437 x 19321\nNon-zeros: 216173 (avg nnz/row ≈ 14.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_Forest_TF16.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_Forest_TF16", "num_rows": 15437, "num_cols": 19321, "nnz": 216173} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Franz_Franz4 (level: level2_medium)\nShape: 6784 x 5252\nNon-zeros: 46528 (avg nnz/row ≈ 6.9)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_Franz_Franz4.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_Franz_Franz4", "num_rows": 6784, "num_cols": 5252, "nnz": 46528} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Franz_Franz7 (level: level2_medium)\nShape: 10164 x 1740\nNon-zeros: 40424 (avg nnz/row ≈ 4.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_Franz_Franz7.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_Franz_Franz7", "num_rows": 10164, "num_cols": 1740, "nnz": 40424} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_G5_IG5-14 (level: level2_medium)\nShape: 6735 x 7621\nNon-zeros: 173337 (avg nnz/row ≈ 25.7)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_G5_IG5-14.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_G5_IG5-14", "num_rows": 6735, "num_cols": 7621, "nnz": 173337} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_G5_IG5-15 (level: level2_medium)\nShape: 11369 x 11987\nNon-zeros: 323509 (avg nnz/row ≈ 28.5)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_G5_IG5-15.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_G5_IG5-15", "num_rows": 11369, "num_cols": 11987, "nnz": 323509} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_G5_IG5-17 (level: level2_medium)\nShape: 30162 x 27944\nNon-zeros: 1035008 (avg nnz/row ≈ 34.3)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_G5_IG5-17.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_G5_IG5-17", "num_rows": 30162, "num_cols": 27944, "nnz": 1035008} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_GL7d_GL7d13 (level: level2_medium)\nShape: 47271 x 8899\nNon-zeros: 356232 (avg nnz/row ≈ 7.5)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_GL7d_GL7d13.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_GL7d_GL7d13", "num_rows": 47271, "num_cols": 8899, "nnz": 356232} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Homology_mk12-b3 (level: level2_medium)\nShape: 51975 x 13860\nNon-zeros: 207900 (avg nnz/row ≈ 4.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_Homology_mk12-b3.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_Homology_mk12-b3", "num_rows": 51975, "num_cols": 13860, "nnz": 207900} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Homology_n2c6-b6 (level: level2_medium)\nShape: 5715 x 4945\nNon-zeros: 40005 (avg nnz/row ≈ 7.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_Homology_n2c6-b6.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_Homology_n2c6-b6", "num_rows": 5715, "num_cols": 4945, "nnz": 40005} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_SPG_EX5 (level: level2_medium)\nShape: 6545 x 6545\nNon-zeros: 295680 (avg nnz/row ≈ 45.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_SPG_EX5.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_SPG_EX5", "num_rows": 6545, "num_cols": 6545, "nnz": 295680} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Trefethen_Trefethen_20000 (level: level2_medium)\nShape: 20000 x 20000\nNon-zeros: 554466 (avg nnz/row ≈ 27.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_Trefethen_Trefethen_20000.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_Trefethen_Trefethen_20000", "num_rows": 20000, "num_cols": 20000, "nnz": 554466} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Trefethen_Trefethen_20000b (level: level2_medium)\nShape: 19999 x 19999\nNon-zeros: 554435 (avg nnz/row ≈ 27.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/JGD_Trefethen_Trefethen_20000b.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "JGD_Trefethen_Trefethen_20000b", "num_rows": 19999, "num_cols": 19999, "nnz": 554435} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: LPnetlib_lp_maros_r7 (level: level2_medium)\nShape: 3136 x 9408\nNon-zeros: 144848 (avg nnz/row ≈ 46.2)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/LPnetlib_lp_maros_r7.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "LPnetlib_lp_maros_r7", "num_rows": 3136, "num_cols": 9408, "nnz": 144848} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: LPnetlib_lp_osa_14 (level: level2_medium)\nShape: 2337 x 54797\nNon-zeros: 317097 (avg nnz/row ≈ 135.7)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/LPnetlib_lp_osa_14.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "LPnetlib_lp_osa_14", "num_rows": 2337, "num_cols": 54797, "nnz": 317097} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: LPnetlib_lp_qap15 (level: level2_medium)\nShape: 6330 x 22275\nNon-zeros: 94950 (avg nnz/row ≈ 15.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/LPnetlib_lp_qap15.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "LPnetlib_lp_qap15", "num_rows": 6330, "num_cols": 22275, "nnz": 94950} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Li_li (level: level2_medium)\nShape: 22695 x 22695\nNon-zeros: 1350309 (avg nnz/row ≈ 59.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Li_li.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Li_li", "num_rows": 22695, "num_cols": 22695, "nnz": 1350309} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: LiuWenzhuo_powersim (level: level2_medium)\nShape: 15838 x 15838\nNon-zeros: 67562 (avg nnz/row ≈ 4.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/LiuWenzhuo_powersim.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "LiuWenzhuo_powersim", "num_rows": 15838, "num_cols": 15838, "nnz": 67562} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: MKS_fp (level: level2_medium)\nShape: 7548 x 7548\nNon-zeros: 848553 (avg nnz/row ≈ 112.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/MKS_fp.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "MKS_fp", "num_rows": 7548, "num_cols": 7548, "nnz": 848553} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ML_Graph_har_10NN (level: level2_medium)\nShape: 10299 x 10299\nNon-zeros: 151736 (avg nnz/row ≈ 14.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/ML_Graph_har_10NN.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "ML_Graph_har_10NN", "num_rows": 10299, "num_cols": 10299, "nnz": 151736} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ML_Graph_optdigits_10NN (level: level2_medium)\nShape: 5620 x 5620\nNon-zeros: 79650 (avg nnz/row ≈ 14.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/ML_Graph_optdigits_10NN.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "ML_Graph_optdigits_10NN", "num_rows": 5620, "num_cols": 5620, "nnz": 79650} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ML_Graph_usps_norm_5NN (level: level2_medium)\nShape: 11000 x 11000\nNon-zeros: 81112 (avg nnz/row ≈ 7.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/ML_Graph_usps_norm_5NN.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "ML_Graph_usps_norm_5NN", "num_rows": 11000, "num_cols": 11000, "nnz": 81112} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr04c (level: level2_medium)\nShape: 4101 x 4101\nNon-zeros: 82682 (avg nnz/row ≈ 20.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Mallya_lhr04c.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Mallya_lhr04c", "num_rows": 4101, "num_cols": 4101, "nnz": 82682} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr07 (level: level2_medium)\nShape: 7337 x 7337\nNon-zeros: 156508 (avg nnz/row ≈ 21.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Mallya_lhr07.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Mallya_lhr07", "num_rows": 7337, "num_cols": 7337, "nnz": 156508} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr07c (level: level2_medium)\nShape: 7337 x 7337\nNon-zeros: 156508 (avg nnz/row ≈ 21.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Mallya_lhr07c.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Mallya_lhr07c", "num_rows": 7337, "num_cols": 7337, "nnz": 156508} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr10 (level: level2_medium)\nShape: 10672 x 10672\nNon-zeros: 232633 (avg nnz/row ≈ 21.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Mallya_lhr10.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Mallya_lhr10", "num_rows": 10672, "num_cols": 10672, "nnz": 232633} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr11 (level: level2_medium)\nShape: 10964 x 10964\nNon-zeros: 233741 (avg nnz/row ≈ 21.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Mallya_lhr11.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Mallya_lhr11", "num_rows": 10964, "num_cols": 10964, "nnz": 233741} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr11c (level: level2_medium)\nShape: 10964 x 10964\nNon-zeros: 233741 (avg nnz/row ≈ 21.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Mallya_lhr11c.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Mallya_lhr11c", "num_rows": 10964, "num_cols": 10964, "nnz": 233741} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr14 (level: level2_medium)\nShape: 14270 x 14270\nNon-zeros: 307858 (avg nnz/row ≈ 21.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Mallya_lhr14.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Mallya_lhr14", "num_rows": 14270, "num_cols": 14270, "nnz": 307858} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr14c (level: level2_medium)\nShape: 14270 x 14270\nNon-zeros: 307858 (avg nnz/row ≈ 21.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Mallya_lhr14c.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Mallya_lhr14c", "num_rows": 14270, "num_cols": 14270, "nnz": 307858} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr17 (level: level2_medium)\nShape: 17576 x 17576\nNon-zeros: 381975 (avg nnz/row ≈ 21.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Mallya_lhr17.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Mallya_lhr17", "num_rows": 17576, "num_cols": 17576, "nnz": 381975} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr17c (level: level2_medium)\nShape: 17576 x 17576\nNon-zeros: 381975 (avg nnz/row ≈ 21.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Mallya_lhr17c.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Mallya_lhr17c", "num_rows": 17576, "num_cols": 17576, "nnz": 381975} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: MathWorks_Kaufhold (level: level2_medium)\nShape: 8765 x 8765\nNon-zeros: 42471 (avg nnz/row ≈ 4.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/MathWorks_Kaufhold.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "MathWorks_Kaufhold", "num_rows": 8765, "num_cols": 8765, "nnz": 42471} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: MathWorks_Pd (level: level2_medium)\nShape: 8081 x 8081\nNon-zeros: 13036 (avg nnz/row ≈ 1.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/MathWorks_Pd.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "MathWorks_Pd", "num_rows": 8081, "num_cols": 8081, "nnz": 13036} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_co9 (level: level2_medium)\nShape: 10789 x 22924\nNon-zeros: 109651 (avg nnz/row ≈ 10.2)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_co9.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_co9", "num_rows": 10789, "num_cols": 22924, "nnz": 109651} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_dbir1 (level: level2_medium)\nShape: 18804 x 45775\nNon-zeros: 1077025 (avg nnz/row ≈ 57.3)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_dbir1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_dbir1", "num_rows": 18804, "num_cols": 45775, "nnz": 1077025} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_dbir2 (level: level2_medium)\nShape: 18906 x 45877\nNon-zeros: 1158159 (avg nnz/row ≈ 61.3)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_dbir2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_dbir2", "num_rows": 18906, "num_cols": 45877, "nnz": 1158159} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_nemsemm1 (level: level2_medium)\nShape: 3945 x 75352\nNon-zeros: 1053986 (avg nnz/row ≈ 267.2)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_nemsemm1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_nemsemm1", "num_rows": 3945, "num_cols": 75352, "nnz": 1053986} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_nsir (level: level2_medium)\nShape: 4453 x 10057\nNon-zeros: 154939 (avg nnz/row ≈ 34.8)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_nsir.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_nsir", "num_rows": 4453, "num_cols": 10057, "nnz": 154939} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_r05 (level: level2_medium)\nShape: 5190 x 9690\nNon-zeros: 104145 (avg nnz/row ≈ 20.1)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_r05.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_r05", "num_rows": 5190, "num_cols": 9690, "nnz": 104145} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_rat (level: level2_medium)\nShape: 3136 x 9408\nNon-zeros: 268908 (avg nnz/row ≈ 85.7)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_rat.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_rat", "num_rows": 3136, "num_cols": 9408, "nnz": 268908} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_scsd8-2b (level: level2_medium)\nShape: 5130 x 35910\nNon-zeros: 112770 (avg nnz/row ≈ 22.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_scsd8-2b.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_scsd8-2b", "num_rows": 5130, "num_cols": 35910, "nnz": 112770} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_scsd8-2c (level: level2_medium)\nShape: 5130 x 35910\nNon-zeros: 112770 (avg nnz/row ≈ 22.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_scsd8-2c.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_scsd8-2c", "num_rows": 5130, "num_cols": 35910, "nnz": 112770} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_scsd8-2r (level: level2_medium)\nShape: 8650 x 60550\nNon-zeros: 190210 (avg nnz/row ≈ 22.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_scsd8-2r.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_scsd8-2r", "num_rows": 8650, "num_cols": 60550, "nnz": 190210} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_stat96v4 (level: level2_medium)\nShape: 3173 x 63076\nNon-zeros: 491336 (avg nnz/row ≈ 154.8)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_stat96v4.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_stat96v4", "num_rows": 3173, "num_cols": 63076, "nnz": 491336} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_stat96v5 (level: level2_medium)\nShape: 2307 x 75779\nNon-zeros: 233921 (avg nnz/row ≈ 101.4)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Meszaros_stat96v5.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Meszaros_stat96v5", "num_rows": 2307, "num_cols": 75779, "nnz": 233921} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Muite_Chebyshev3 (level: level2_medium)\nShape: 4101 x 4101\nNon-zeros: 36879 (avg nnz/row ≈ 9.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Muite_Chebyshev3.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Muite_Chebyshev3", "num_rows": 4101, "num_cols": 4101, "nnz": 36879} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mycielski_mycielskian13 (level: level2_medium)\nShape: 6143 x 6143\nNon-zeros: 1227742 (avg nnz/row ≈ 199.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Mycielski_mycielskian13.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Mycielski_mycielskian13", "num_rows": 6143, "num_cols": 6143, "nnz": 1227742} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ND_nd3k (level: level2_medium)\nShape: 9000 x 9000\nNon-zeros: 3279690 (avg nnz/row ≈ 364.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/ND_nd3k.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "ND_nd3k", "num_rows": 9000, "num_cols": 9000, "nnz": 3279690} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: NYPA_Maragal_6 (level: level2_medium)\nShape: 21255 x 10152\nNon-zeros: 537694 (avg nnz/row ≈ 25.3)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/NYPA_Maragal_6.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "NYPA_Maragal_6", "num_rows": 21255, "num_cols": 10152, "nnz": 537694} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nasa_barth (level: level2_medium)\nShape: 6691 x 6691\nNon-zeros: 26439 (avg nnz/row ≈ 4.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nasa_barth.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nasa_barth", "num_rows": 6691, "num_cols": 6691, "nnz": 26439} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nasa_barth5 (level: level2_medium)\nShape: 15606 x 15606\nNon-zeros: 61484 (avg nnz/row ≈ 3.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nasa_barth5.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nasa_barth5", "num_rows": 15606, "num_cols": 15606, "nnz": 61484} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nasa_shuttle_eddy (level: level2_medium)\nShape: 10429 x 10429\nNon-zeros: 103599 (avg nnz/row ≈ 9.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nasa_shuttle_eddy.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nasa_shuttle_eddy", "num_rows": 10429, "num_cols": 10429, "nnz": 103599} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth01 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 725054 (avg nnz/row ≈ 76.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth01.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth01", "num_rows": 9506, "num_cols": 9506, "nnz": 725054} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth02 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 394808 (avg nnz/row ≈ 41.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth02.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth02", "num_rows": 9506, "num_cols": 9506, "nnz": 394808} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth06 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 394808 (avg nnz/row ≈ 41.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth06.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth06", "num_rows": 9506, "num_cols": 9506, "nnz": 394808} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth07 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 394812 (avg nnz/row ≈ 41.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth07.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth07", "num_rows": 9506, "num_cols": 9506, "nnz": 394812} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth09 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 395506 (avg nnz/row ≈ 41.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth09.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth09", "num_rows": 9506, "num_cols": 9506, "nnz": 395506} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth10 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 401448 (avg nnz/row ≈ 42.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth10.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth10", "num_rows": 9506, "num_cols": 9506, "nnz": 401448} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth11 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 408264 (avg nnz/row ≈ 42.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth11.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth11", "num_rows": 9506, "num_cols": 9506, "nnz": 408264} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth15 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 539802 (avg nnz/row ≈ 56.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth15.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth15", "num_rows": 9506, "num_cols": 9506, "nnz": 539802} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth17 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 629620 (avg nnz/row ≈ 66.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth17.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth17", "num_rows": 9506, "num_cols": 9506, "nnz": 629620} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth19 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 818302 (avg nnz/row ≈ 86.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth19.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth19", "num_rows": 9506, "num_cols": 9506, "nnz": 818302} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth20 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 971870 (avg nnz/row ≈ 102.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth20.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth20", "num_rows": 9506, "num_cols": 9506, "nnz": 971870} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth22 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 1358832 (avg nnz/row ≈ 142.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth22.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth22", "num_rows": 9506, "num_cols": 9506, "nnz": 1358832} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth24 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 1506550 (avg nnz/row ≈ 158.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth24.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth24", "num_rows": 9506, "num_cols": 9506, "nnz": 1506550} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nemeth_nemeth25 (level: level2_medium)\nShape: 9506 x 9506\nNon-zeros: 1511758 (avg nnz/row ≈ 159.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Nemeth_nemeth25.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Nemeth_nemeth25", "num_rows": 9506, "num_cols": 9506, "nnz": 1511758} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Newman_as-22july06 (level: level2_medium)\nShape: 22963 x 22963\nNon-zeros: 96872 (avg nnz/row ≈ 4.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Newman_as-22july06.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Newman_as-22july06", "num_rows": 22963, "num_cols": 22963, "nnz": 96872} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Newman_power (level: level2_medium)\nShape: 4941 x 4941\nNon-zeros: 13188 (avg nnz/row ≈ 2.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Newman_power.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Newman_power", "num_rows": 4941, "num_cols": 4941, "nnz": 13188} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Norris_fv1 (level: level2_medium)\nShape: 9604 x 9604\nNon-zeros: 85264 (avg nnz/row ≈ 8.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Norris_fv1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Norris_fv1", "num_rows": 9604, "num_cols": 9604, "nnz": 85264} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Norris_heart1 (level: level2_medium)\nShape: 3557 x 3557\nNon-zeros: 1387773 (avg nnz/row ≈ 390.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Norris_heart1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Norris_heart1", "num_rows": 3557, "num_cols": 3557, "nnz": 1387773} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_chipcool0 (level: level2_medium)\nShape: 20082 x 20082\nNon-zeros: 281150 (avg nnz/row ≈ 14.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Oberwolfach_chipcool0.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Oberwolfach_chipcool0", "num_rows": 20082, "num_cols": 20082, "nnz": 281150} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_gyro (level: level2_medium)\nShape: 17361 x 17361\nNon-zeros: 1021159 (avg nnz/row ≈ 58.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Oberwolfach_gyro.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Oberwolfach_gyro", "num_rows": 17361, "num_cols": 17361, "nnz": 1021159} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_gyro_k (level: level2_medium)\nShape: 17361 x 17361\nNon-zeros: 1021159 (avg nnz/row ≈ 58.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Oberwolfach_gyro_k.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Oberwolfach_gyro_k", "num_rows": 17361, "num_cols": 17361, "nnz": 1021159} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_t2dah_a (level: level2_medium)\nShape: 11445 x 11445\nNon-zeros: 176117 (avg nnz/row ≈ 15.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Oberwolfach_t2dah_a.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Oberwolfach_t2dah_a", "num_rows": 11445, "num_cols": 11445, "nnz": 176117} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_t2dal_a (level: level2_medium)\nShape: 4257 x 4257\nNon-zeros: 37465 (avg nnz/row ≈ 8.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Oberwolfach_t2dal_a.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Oberwolfach_t2dal_a", "num_rows": 4257, "num_cols": 4257, "nnz": 37465} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_t3dl (level: level2_medium)\nShape: 20360 x 20360\nNon-zeros: 509866 (avg nnz/row ≈ 25.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Oberwolfach_t3dl.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Oberwolfach_t3dl", "num_rows": 20360, "num_cols": 20360, "nnz": 509866} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_t3dl_a (level: level2_medium)\nShape: 20360 x 20360\nNon-zeros: 509866 (avg nnz/row ≈ 25.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Oberwolfach_t3dl_a.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Oberwolfach_t3dl_a", "num_rows": 20360, "num_cols": 20360, "nnz": 509866} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_t3dl_e (level: level2_medium)\nShape: 20360 x 20360\nNon-zeros: 20360 (avg nnz/row ≈ 1.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Oberwolfach_t3dl_e.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Oberwolfach_t3dl_e", "num_rows": 20360, "num_cols": 20360, "nnz": 20360} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Okunbor_aft01 (level: level2_medium)\nShape: 8205 x 8205\nNon-zeros: 125567 (avg nnz/row ≈ 15.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Okunbor_aft01.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Okunbor_aft01", "num_rows": 8205, "num_cols": 8205, "nnz": 125567} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_Na5 (level: level2_medium)\nShape: 5832 x 5832\nNon-zeros: 305630 (avg nnz/row ≈ 52.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/PARSEC_Na5.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "PARSEC_Na5", "num_rows": 5832, "num_cols": 5832, "nnz": 305630} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_Si10H16 (level: level2_medium)\nShape: 17077 x 17077\nNon-zeros: 875923 (avg nnz/row ≈ 51.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/PARSEC_Si10H16.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "PARSEC_Si10H16", "num_rows": 17077, "num_cols": 17077, "nnz": 875923} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_Si5H12 (level: level2_medium)\nShape: 19896 x 19896\nNon-zeros: 738598 (avg nnz/row ≈ 37.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/PARSEC_Si5H12.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "PARSEC_Si5H12", "num_rows": 19896, "num_cols": 19896, "nnz": 738598} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_SiH4 (level: level2_medium)\nShape: 5041 x 5041\nNon-zeros: 171903 (avg nnz/row ≈ 34.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/PARSEC_SiH4.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "PARSEC_SiH4", "num_rows": 5041, "num_cols": 5041, "nnz": 171903} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_benzene (level: level2_medium)\nShape: 8219 x 8219\nNon-zeros: 242669 (avg nnz/row ≈ 29.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/PARSEC_benzene.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "PARSEC_benzene", "num_rows": 8219, "num_cols": 8219, "nnz": 242669} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: POLYFLOW_invextr1_new (level: level2_medium)\nShape: 30412 x 30412\nNon-zeros: 1793881 (avg nnz/row ≈ 59.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/POLYFLOW_invextr1_new.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "POLYFLOW_invextr1_new", "num_rows": 30412, "num_cols": 30412, "nnz": 1793881} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: POLYFLOW_mixtank_new (level: level2_medium)\nShape: 29957 x 29957\nNon-zeros: 1995041 (avg nnz/row ≈ 66.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/POLYFLOW_mixtank_new.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "POLYFLOW_mixtank_new", "num_rows": 29957, "num_cols": 29957, "nnz": 1995041} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_EAT_RS (level: level2_medium)\nShape: 23219 x 23219\nNon-zeros: 325592 (avg nnz/row ≈ 14.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_EAT_RS.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_EAT_RS", "num_rows": 23219, "num_cols": 23219, "nnz": 325592} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_Erdos02 (level: level2_medium)\nShape: 6927 x 6927\nNon-zeros: 16944 (avg nnz/row ≈ 2.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_Erdos02.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_Erdos02", "num_rows": 6927, "num_cols": 6927, "nnz": 16944} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_Erdos972 (level: level2_medium)\nShape: 5488 x 5488\nNon-zeros: 14170 (avg nnz/row ≈ 2.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_Erdos972.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_Erdos972", "num_rows": 5488, "num_cols": 5488, "nnz": 14170} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_Erdos982 (level: level2_medium)\nShape: 5822 x 5822\nNon-zeros: 14750 (avg nnz/row ≈ 2.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_Erdos982.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_Erdos982", "num_rows": 5822, "num_cols": 5822, "nnz": 14750} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_Erdos992 (level: level2_medium)\nShape: 6100 x 6100\nNon-zeros: 15030 (avg nnz/row ≈ 2.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_Erdos992.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_Erdos992", "num_rows": 6100, "num_cols": 6100, "nnz": 15030} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_FA (level: level2_medium)\nShape: 10617 x 10617\nNon-zeros: 72176 (avg nnz/row ≈ 6.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_FA.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_FA", "num_rows": 10617, "num_cols": 10617, "nnz": 72176} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_Kohonen (level: level2_medium)\nShape: 4470 x 4470\nNon-zeros: 12731 (avg nnz/row ≈ 2.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_Kohonen.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_Kohonen", "num_rows": 4470, "num_cols": 4470, "nnz": 12731} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_Lederberg (level: level2_medium)\nShape: 8843 x 8843\nNon-zeros: 41601 (avg nnz/row ≈ 4.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_Lederberg.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_Lederberg", "num_rows": 8843, "num_cols": 8843, "nnz": 41601} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_Reuters911 (level: level2_medium)\nShape: 13332 x 13332\nNon-zeros: 296076 (avg nnz/row ≈ 22.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_Reuters911.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_Reuters911", "num_rows": 13332, "num_cols": 13332, "nnz": 296076} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_Zewail (level: level2_medium)\nShape: 6752 x 6752\nNon-zeros: 54233 (avg nnz/row ≈ 8.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_Zewail.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_Zewail", "num_rows": 6752, "num_cols": 6752, "nnz": 54233} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_foldoc (level: level2_medium)\nShape: 13356 x 13356\nNon-zeros: 120238 (avg nnz/row ≈ 9.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_foldoc.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_foldoc", "num_rows": 13356, "num_cols": 13356, "nnz": 120238} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_geom (level: level2_medium)\nShape: 7343 x 7343\nNon-zeros: 23796 (avg nnz/row ≈ 3.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pajek_geom.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pajek_geom", "num_rows": 7343, "num_cols": 7343, "nnz": 23796} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pothen_barth (level: level2_medium)\nShape: 6691 x 6691\nNon-zeros: 46187 (avg nnz/row ≈ 6.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pothen_barth.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pothen_barth", "num_rows": 6691, "num_cols": 6691, "nnz": 46187} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pothen_barth5 (level: level2_medium)\nShape: 15606 x 15606\nNon-zeros: 107362 (avg nnz/row ≈ 6.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pothen_barth5.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pothen_barth5", "num_rows": 15606, "num_cols": 15606, "nnz": 107362} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pothen_bodyy4 (level: level2_medium)\nShape: 17546 x 17546\nNon-zeros: 121938 (avg nnz/row ≈ 6.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pothen_bodyy4.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pothen_bodyy4", "num_rows": 17546, "num_cols": 17546, "nnz": 121938} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pothen_bodyy6 (level: level2_medium)\nShape: 19366 x 19366\nNon-zeros: 134748 (avg nnz/row ≈ 7.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pothen_bodyy6.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pothen_bodyy6", "num_rows": 19366, "num_cols": 19366, "nnz": 134748} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pothen_tandem_vtx (level: level2_medium)\nShape: 18454 x 18454\nNon-zeros: 253350 (avg nnz/row ≈ 13.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Pothen_tandem_vtx.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Pothen_tandem_vtx", "num_rows": 18454, "num_cols": 18454, "nnz": 253350} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Puri_ABACUS_shell_ud (level: level2_medium)\nShape: 23412 x 23412\nNon-zeros: 218484 (avg nnz/row ≈ 9.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Puri_ABACUS_shell_ud.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Puri_ABACUS_shell_ud", "num_rows": 23412, "num_cols": 23412, "nnz": 218484} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: QY_case9 (level: level2_medium)\nShape: 14454 x 14454\nNon-zeros: 147972 (avg nnz/row ≈ 10.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/QY_case9.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "QY_case9", "num_rows": 14454, "num_cols": 14454, "nnz": 147972} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Rommes_bips98_1450 (level: level2_medium)\nShape: 11305 x 11305\nNon-zeros: 1450 (avg nnz/row ≈ 0.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Rommes_bips98_1450.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Rommes_bips98_1450", "num_rows": 11305, "num_cols": 11305, "nnz": 1450} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_Oregon-1 (level: level2_medium)\nShape: 11492 x 11492\nNon-zeros: 44986 (avg nnz/row ≈ 3.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_Oregon-1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_Oregon-1", "num_rows": 11492, "num_cols": 11492, "nnz": 44986} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_Oregon-2 (level: level2_medium)\nShape: 11806 x 11806\nNon-zeros: 65460 (avg nnz/row ≈ 5.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_Oregon-2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_Oregon-2", "num_rows": 11806, "num_cols": 11806, "nnz": 65460} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_as-caida (level: level2_medium)\nShape: 31379 x 31379\nNon-zeros: 106762 (avg nnz/row ≈ 3.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_as-caida.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_as-caida", "num_rows": 31379, "num_cols": 31379, "nnz": 106762} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_ca-AstroPh (level: level2_medium)\nShape: 18772 x 18772\nNon-zeros: 396160 (avg nnz/row ≈ 21.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_ca-AstroPh.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_ca-AstroPh", "num_rows": 18772, "num_cols": 18772, "nnz": 396160} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_ca-HepPh (level: level2_medium)\nShape: 12008 x 12008\nNon-zeros: 237010 (avg nnz/row ≈ 19.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_ca-HepPh.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_ca-HepPh", "num_rows": 12008, "num_cols": 12008, "nnz": 237010} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_p2p-Gnutella04 (level: level2_medium)\nShape: 10879 x 10879\nNon-zeros: 39994 (avg nnz/row ≈ 3.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_p2p-Gnutella04.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_p2p-Gnutella04", "num_rows": 10879, "num_cols": 10879, "nnz": 39994} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_p2p-Gnutella05 (level: level2_medium)\nShape: 8846 x 8846\nNon-zeros: 31839 (avg nnz/row ≈ 3.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_p2p-Gnutella05.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_p2p-Gnutella05", "num_rows": 8846, "num_cols": 8846, "nnz": 31839} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_p2p-Gnutella06 (level: level2_medium)\nShape: 8717 x 8717\nNon-zeros: 31525 (avg nnz/row ≈ 3.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_p2p-Gnutella06.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_p2p-Gnutella06", "num_rows": 8717, "num_cols": 8717, "nnz": 31525} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_p2p-Gnutella08 (level: level2_medium)\nShape: 6301 x 6301\nNon-zeros: 20777 (avg nnz/row ≈ 3.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_p2p-Gnutella08.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_p2p-Gnutella08", "num_rows": 6301, "num_cols": 6301, "nnz": 20777} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_p2p-Gnutella09 (level: level2_medium)\nShape: 8114 x 8114\nNon-zeros: 26013 (avg nnz/row ≈ 3.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_p2p-Gnutella09.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_p2p-Gnutella09", "num_rows": 8114, "num_cols": 8114, "nnz": 26013} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_p2p-Gnutella24 (level: level2_medium)\nShape: 26518 x 26518\nNon-zeros: 65369 (avg nnz/row ≈ 2.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_p2p-Gnutella24.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_p2p-Gnutella24", "num_rows": 26518, "num_cols": 26518, "nnz": 65369} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_soc-sign-bitcoin-alpha (level: level2_medium)\nShape: 3783 x 3783\nNon-zeros: 24186 (avg nnz/row ≈ 6.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_soc-sign-bitcoin-alpha.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_soc-sign-bitcoin-alpha", "num_rows": 3783, "num_cols": 3783, "nnz": 24186} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_soc-sign-bitcoin-otc (level: level2_medium)\nShape: 5881 x 5881\nNon-zeros: 35592 (avg nnz/row ≈ 6.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_soc-sign-bitcoin-otc.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_soc-sign-bitcoin-otc", "num_rows": 5881, "num_cols": 5881, "nnz": 35592} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_sx-mathoverflow (level: level2_medium)\nShape: 24818 x 24818\nNon-zeros: 239978 (avg nnz/row ≈ 9.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_sx-mathoverflow.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_sx-mathoverflow", "num_rows": 24818, "num_cols": 24818, "nnz": 239978} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_wiki-RfA (level: level2_medium)\nShape: 11380 x 11380\nNon-zeros: 188077 (avg nnz/row ≈ 16.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/SNAP_wiki-RfA.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "SNAP_wiki-RfA", "num_rows": 11380, "num_cols": 11380, "nnz": 188077} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-30 (level: level2_medium)\nShape: 5321 x 5321\nNon-zeros: 65693 (avg nnz/row ≈ 12.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-30.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-30", "num_rows": 5321, "num_cols": 5321, "nnz": 65693} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-31 (level: level2_medium)\nShape: 5339 x 5339\nNon-zeros: 78571 (avg nnz/row ≈ 14.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-31.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-31", "num_rows": 5339, "num_cols": 5339, "nnz": 78571} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-33 (level: level2_medium)\nShape: 6317 x 6317\nNon-zeros: 56123 (avg nnz/row ≈ 8.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-33.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-33", "num_rows": 6317, "num_cols": 6317, "nnz": 56123} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-40 (level: level2_medium)\nShape: 9941 x 9941\nNon-zeros: 81501 (avg nnz/row ≈ 8.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-40.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-40", "num_rows": 9941, "num_cols": 9941, "nnz": 81501} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-41 (level: level2_medium)\nShape: 9769 x 9769\nNon-zeros: 101745 (avg nnz/row ≈ 10.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-41.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-41", "num_rows": 9769, "num_cols": 9769, "nnz": 101745} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-43 (level: level2_medium)\nShape: 11125 x 11125\nNon-zeros: 123675 (avg nnz/row ≈ 11.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-43.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-43", "num_rows": 11125, "num_cols": 11125, "nnz": 123675} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-45 (level: level2_medium)\nShape: 13206 x 13206\nNon-zeros: 174452 (avg nnz/row ≈ 13.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-45.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-45", "num_rows": 13206, "num_cols": 13206, "nnz": 174452} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-47 (level: level2_medium)\nShape: 15343 x 15343\nNon-zeros: 211401 (avg nnz/row ≈ 13.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-47.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-47", "num_rows": 15343, "num_cols": 15343, "nnz": 211401} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-49 (level: level2_medium)\nShape: 21132 x 21132\nNon-zeros: 157042 (avg nnz/row ≈ 7.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-49.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-49", "num_rows": 21132, "num_cols": 21132, "nnz": 157042} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-50 (level: level2_medium)\nShape: 22401 x 22401\nNon-zeros: 193625 (avg nnz/row ≈ 8.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-50.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-50", "num_rows": 22401, "num_cols": 22401, "nnz": 193625} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-51 (level: level2_medium)\nShape: 23196 x 23196\nNon-zeros: 203050 (avg nnz/row ≈ 8.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-51.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-51", "num_rows": 23196, "num_cols": 23196, "nnz": 203050} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-53 (level: level2_medium)\nShape: 30235 x 30235\nNon-zeros: 372213 (avg nnz/row ≈ 12.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMNA_c-53.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMNA_c-53", "num_rows": 30235, "num_cols": 30235, "nnz": 372213} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMSDS_2D_27628_bjtcai (level: level2_medium)\nShape: 27628 x 27628\nNon-zeros: 442898 (avg nnz/row ≈ 16.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_IBMSDS_2D_27628_bjtcai.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_IBMSDS_2D_27628_bjtcai", "num_rows": 27628, "num_cols": 27628, "nnz": 442898} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_ISEI_igbt3 (level: level2_medium)\nShape: 10938 x 10938\nNon-zeros: 234006 (avg nnz/row ≈ 21.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schenk_ISEI_igbt3.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schenk_ISEI_igbt3", "num_rows": 10938, "num_cols": 10938, "nnz": 234006} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schulthess_N_reactome (level: level2_medium)\nShape: 10204 x 16559\nNon-zeros: 43816 (avg nnz/row ≈ 4.3)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Schulthess_N_reactome.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Schulthess_N_reactome", "num_rows": 10204, "num_cols": 16559, "nnz": 43816} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Shen_e40r0100 (level: level2_medium)\nShape: 17281 x 17281\nNon-zeros: 553562 (avg nnz/row ≈ 32.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Shen_e40r0100.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Shen_e40r0100", "num_rows": 17281, "num_cols": 17281, "nnz": 553562} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Shen_shermanACd (level: level2_medium)\nShape: 6136 x 6136\nNon-zeros: 53329 (avg nnz/row ≈ 8.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Shen_shermanACd.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Shen_shermanACd", "num_rows": 6136, "num_cols": 6136, "nnz": 53329} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Simon_olafu (level: level2_medium)\nShape: 16146 x 16146\nNon-zeros: 1015156 (avg nnz/row ≈ 62.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Simon_olafu.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Simon_olafu", "num_rows": 16146, "num_cols": 16146, "nnz": 1015156} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Simon_raefsky1 (level: level2_medium)\nShape: 3242 x 3242\nNon-zeros: 294276 (avg nnz/row ≈ 90.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Simon_raefsky1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Simon_raefsky1", "num_rows": 3242, "num_cols": 3242, "nnz": 294276} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Simon_raefsky2 (level: level2_medium)\nShape: 3242 x 3242\nNon-zeros: 294276 (avg nnz/row ≈ 90.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Simon_raefsky2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Simon_raefsky2", "num_rows": 3242, "num_cols": 3242, "nnz": 294276} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Simon_raefsky3 (level: level2_medium)\nShape: 21200 x 21200\nNon-zeros: 1488768 (avg nnz/row ≈ 70.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Simon_raefsky3.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Simon_raefsky3", "num_rows": 21200, "num_cols": 21200, "nnz": 1488768} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Simon_raefsky6 (level: level2_medium)\nShape: 3402 x 3402\nNon-zeros: 137845 (avg nnz/row ≈ 40.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Simon_raefsky6.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Simon_raefsky6", "num_rows": 3402, "num_cols": 3402, "nnz": 137845} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TAMU_SmartGridCenter_ACTIVSg2000 (level: level2_medium)\nShape: 4000 x 4000\nNon-zeros: 29336 (avg nnz/row ≈ 7.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TAMU_SmartGridCenter_ACTIVSg2000.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TAMU_SmartGridCenter_ACTIVSg2000", "num_rows": 4000, "num_cols": 4000, "nnz": 29336} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TKK_t2d_q4 (level: level2_medium)\nShape: 9801 x 9801\nNon-zeros: 87025 (avg nnz/row ≈ 8.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TKK_t2d_q4.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TKK_t2d_q4", "num_rows": 9801, "num_cols": 9801, "nnz": 87025} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TKK_tube1 (level: level2_medium)\nShape: 21498 x 21498\nNon-zeros: 897056 (avg nnz/row ≈ 41.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TKK_tube1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TKK_tube1", "num_rows": 21498, "num_cols": 21498, "nnz": 897056} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TKK_tube2 (level: level2_medium)\nShape: 21498 x 21498\nNon-zeros: 897056 (avg nnz/row ≈ 41.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TKK_tube2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TKK_tube2", "num_rows": 21498, "num_cols": 21498, "nnz": 897056} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TOKAMAK_utm5940 (level: level2_medium)\nShape: 5940 x 5940\nNon-zeros: 83842 (avg nnz/row ≈ 14.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TOKAMAK_utm5940.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TOKAMAK_utm5940", "num_rows": 5940, "num_cols": 5940, "nnz": 83842} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_FS_b162_c1 (level: level2_medium)\nShape: 10798 x 10798\nNon-zeros: 608540 (avg nnz/row ≈ 56.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TSOPF_TSOPF_FS_b162_c1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TSOPF_TSOPF_FS_b162_c1", "num_rows": 10798, "num_cols": 10798, "nnz": 608540} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b162_c1 (level: level2_medium)\nShape: 5374 x 5374\nNon-zeros: 205399 (avg nnz/row ≈ 38.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TSOPF_TSOPF_RS_b162_c1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TSOPF_TSOPF_RS_b162_c1", "num_rows": 5374, "num_cols": 5374, "nnz": 205399} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b162_c3 (level: level2_medium)\nShape: 15374 x 15374\nNon-zeros: 610299 (avg nnz/row ≈ 39.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TSOPF_TSOPF_RS_b162_c3.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TSOPF_TSOPF_RS_b162_c3", "num_rows": 15374, "num_cols": 15374, "nnz": 610299} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b162_c4 (level: level2_medium)\nShape: 20374 x 20374\nNon-zeros: 812749 (avg nnz/row ≈ 39.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TSOPF_TSOPF_RS_b162_c4.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TSOPF_TSOPF_RS_b162_c4", "num_rows": 20374, "num_cols": 20374, "nnz": 812749} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b2052_c1 (level: level2_medium)\nShape: 25626 x 25626\nNon-zeros: 6761100 (avg nnz/row ≈ 263.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TSOPF_TSOPF_RS_b2052_c1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TSOPF_TSOPF_RS_b2052_c1", "num_rows": 25626, "num_cols": 25626, "nnz": 6761100} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b300_c1 (level: level2_medium)\nShape: 14538 x 14538\nNon-zeros: 1474325 (avg nnz/row ≈ 101.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TSOPF_TSOPF_RS_b300_c1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TSOPF_TSOPF_RS_b300_c1", "num_rows": 14538, "num_cols": 14538, "nnz": 1474325} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b300_c2 (level: level2_medium)\nShape: 28338 x 28338\nNon-zeros: 2943887 (avg nnz/row ≈ 103.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/TSOPF_TSOPF_RS_b300_c2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "TSOPF_TSOPF_RS_b300_c2", "num_rows": 28338, "num_cols": 28338, "nnz": 2943887} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VDOL_dynamicSoaringProblem_7 (level: level2_medium)\nShape: 3511 x 3511\nNon-zeros: 37680 (avg nnz/row ≈ 10.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VDOL_dynamicSoaringProblem_7.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VDOL_dynamicSoaringProblem_7", "num_rows": 3511, "num_cols": 3511, "nnz": 37680} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VDOL_freeFlyingRobot_11 (level: level2_medium)\nShape: 5438 x 5438\nNon-zeros: 40054 (avg nnz/row ≈ 7.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VDOL_freeFlyingRobot_11.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VDOL_freeFlyingRobot_11", "num_rows": 5438, "num_cols": 5438, "nnz": 40054} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VDOL_hangGlider_5 (level: level2_medium)\nShape: 16011 x 16011\nNon-zeros: 155246 (avg nnz/row ≈ 9.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VDOL_hangGlider_5.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VDOL_hangGlider_5", "num_rows": 16011, "num_cols": 16011, "nnz": 155246} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VDOL_kineticBatchReactor_6 (level: level2_medium)\nShape: 7773 x 7773\nNon-zeros: 82500 (avg nnz/row ≈ 10.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VDOL_kineticBatchReactor_6.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VDOL_kineticBatchReactor_6", "num_rows": 7773, "num_cols": 7773, "nnz": 82500} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VDOL_lowThrust_11 (level: level2_medium)\nShape: 18368 x 18368\nNon-zeros: 223801 (avg nnz/row ≈ 12.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VDOL_lowThrust_11.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VDOL_lowThrust_11", "num_rows": 18368, "num_cols": 18368, "nnz": 223801} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VDOL_lowThrust_4 (level: level2_medium)\nShape: 13562 x 13562\nNon-zeros: 160947 (avg nnz/row ≈ 11.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VDOL_lowThrust_4.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VDOL_lowThrust_4", "num_rows": 13562, "num_cols": 13562, "nnz": 160947} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VanVelzen_Zd_Jac2 (level: level2_medium)\nShape: 22835 x 22835\nNon-zeros: 1642833 (avg nnz/row ≈ 71.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VanVelzen_Zd_Jac2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VanVelzen_Zd_Jac2", "num_rows": 22835, "num_cols": 22835, "nnz": 1642833} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VanVelzen_Zd_Jac2_db (level: level2_medium)\nShape: 22835 x 22835\nNon-zeros: 676439 (avg nnz/row ≈ 29.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VanVelzen_Zd_Jac2_db.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VanVelzen_Zd_Jac2_db", "num_rows": 22835, "num_cols": 22835, "nnz": 676439} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VanVelzen_Zd_Jac3 (level: level2_medium)\nShape: 22835 x 22835\nNon-zeros: 1916152 (avg nnz/row ≈ 83.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VanVelzen_Zd_Jac3.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VanVelzen_Zd_Jac3", "num_rows": 22835, "num_cols": 22835, "nnz": 1916152} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VanVelzen_Zd_Jac3_db (level: level2_medium)\nShape: 22835 x 22835\nNon-zeros: 713907 (avg nnz/row ≈ 31.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VanVelzen_Zd_Jac3_db.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VanVelzen_Zd_Jac3_db", "num_rows": 22835, "num_cols": 22835, "nnz": 713907} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VanVelzen_Zd_Jac6 (level: level2_medium)\nShape: 22835 x 22835\nNon-zeros: 1711983 (avg nnz/row ≈ 75.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VanVelzen_Zd_Jac6.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VanVelzen_Zd_Jac6", "num_rows": 22835, "num_cols": 22835, "nnz": 1711983} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VanVelzen_Zd_Jac6_db (level: level2_medium)\nShape: 22835 x 22835\nNon-zeros: 663643 (avg nnz/row ≈ 29.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VanVelzen_Zd_Jac6_db.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VanVelzen_Zd_Jac6_db", "num_rows": 22835, "num_cols": 22835, "nnz": 663643} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VanVelzen_std1_Jac2 (level: level2_medium)\nShape: 21982 x 21982\nNon-zeros: 1248731 (avg nnz/row ≈ 56.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VanVelzen_std1_Jac2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VanVelzen_std1_Jac2", "num_rows": 21982, "num_cols": 21982, "nnz": 1248731} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VanVelzen_std1_Jac2_db (level: level2_medium)\nShape: 21982 x 21982\nNon-zeros: 498771 (avg nnz/row ≈ 22.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VanVelzen_std1_Jac2_db.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VanVelzen_std1_Jac2_db", "num_rows": 21982, "num_cols": 21982, "nnz": 498771} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VanVelzen_std1_Jac3_db (level: level2_medium)\nShape: 21982 x 21982\nNon-zeros: 531826 (avg nnz/row ≈ 24.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/VanVelzen_std1_Jac3_db.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "VanVelzen_std1_Jac3_db", "num_rows": 21982, "num_cols": 21982, "nnz": 531826} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Wang_swang1 (level: level2_medium)\nShape: 3169 x 3169\nNon-zeros: 20841 (avg nnz/row ≈ 6.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Wang_swang1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Wang_swang1", "num_rows": 3169, "num_cols": 3169, "nnz": 20841} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Wang_swang2 (level: level2_medium)\nShape: 3169 x 3169\nNon-zeros: 20841 (avg nnz/row ≈ 6.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Wang_swang2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Wang_swang2", "num_rows": 3169, "num_cols": 3169, "nnz": 20841} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Zitney_hydr1c (level: level2_medium)\nShape: 5308 x 5308\nNon-zeros: 23752 (avg nnz/row ≈ 4.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Zitney_hydr1c.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Zitney_hydr1c", "num_rows": 5308, "num_cols": 5308, "nnz": 23752} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Zitney_rdist1 (level: level2_medium)\nShape: 4134 x 4134\nNon-zeros: 94408 (avg nnz/row ≈ 22.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Zitney_rdist1.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Zitney_rdist1", "num_rows": 4134, "num_cols": 4134, "nnz": 94408} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Zitney_rdist2 (level: level2_medium)\nShape: 3198 x 3198\nNon-zeros: 56934 (avg nnz/row ≈ 17.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/Zitney_rdist2.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "Zitney_rdist2", "num_rows": 3198, "num_cols": 3198, "nnz": 56934} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: vanHeukelum_cage10 (level: level2_medium)\nShape: 11397 x 11397\nNon-zeros: 150645 (avg nnz/row ≈ 13.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/vanHeukelum_cage10.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "vanHeukelum_cage10", "num_rows": 11397, "num_cols": 11397, "nnz": 150645} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: vanHeukelum_cage9 (level: level2_medium)\nShape: 3534 x 3534\nNon-zeros: 41594 (avg nnz/row ≈ 11.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level2_medium/vanHeukelum_cage9.bin", "op_type": "spgemm", "K": 0, "level": "level2_medium", "matrix_name": "vanHeukelum_cage9", "num_rows": 3534, "num_cols": 3534, "nnz": 41594} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: AG-Monien_bfly (level: level3_large)\nShape: 49152 x 49152\nNon-zeros: 196608 (avg nnz/row ≈ 4.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/AG-Monien_bfly.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "AG-Monien_bfly", "num_rows": 49152, "num_cols": 49152, "nnz": 196608} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: AG-Monien_brack2 (level: level3_large)\nShape: 62631 x 62631\nNon-zeros: 733118 (avg nnz/row ≈ 11.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/AG-Monien_brack2.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "AG-Monien_brack2", "num_rows": 62631, "num_cols": 62631, "nnz": 733118} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: AG-Monien_ccc (level: level3_large)\nShape: 49152 x 49152\nNon-zeros: 147456 (avg nnz/row ≈ 3.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/AG-Monien_ccc.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "AG-Monien_ccc", "num_rows": 49152, "num_cols": 49152, "nnz": 147456} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ATandT_onetone1 (level: level3_large)\nShape: 36057 x 36057\nNon-zeros: 341088 (avg nnz/row ≈ 9.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/ATandT_onetone1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "ATandT_onetone1", "num_rows": 36057, "num_cols": 36057, "nnz": 341088} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ATandT_onetone2 (level: level3_large)\nShape: 36057 x 36057\nNon-zeros: 227628 (avg nnz/row ≈ 6.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/ATandT_onetone2.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "ATandT_onetone2", "num_rows": 36057, "num_cols": 36057, "nnz": 227628} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Andrianov_net125 (level: level3_large)\nShape: 36720 x 36720\nNon-zeros: 2577200 (avg nnz/row ≈ 70.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Andrianov_net125.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Andrianov_net125", "num_rows": 36720, "num_cols": 36720, "nnz": 2577200} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Andrianov_net4-1 (level: level3_large)\nShape: 88343 x 88343\nNon-zeros: 2441727 (avg nnz/row ≈ 27.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Andrianov_net4-1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Andrianov_net4-1", "num_rows": 88343, "num_cols": 88343, "nnz": 2441727} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Averous_epb3 (level: level3_large)\nShape: 84617 x 84617\nNon-zeros: 463625 (avg nnz/row ≈ 5.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Averous_epb3.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Averous_epb3", "num_rows": 84617, "num_cols": 84617, "nnz": 463625} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Barabasi_NotreDame_actors (level: level3_large)\nShape: 392400 x 127823\nNon-zeros: 1470404 (avg nnz/row ≈ 3.7)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Barabasi_NotreDame_actors.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Barabasi_NotreDame_actors", "num_rows": 392400, "num_cols": 127823, "nnz": 1470404} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bomhof_circuit_4 (level: level3_large)\nShape: 80209 x 80209\nNon-zeros: 307604 (avg nnz/row ≈ 3.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Bomhof_circuit_4.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Bomhof_circuit_4", "num_rows": 80209, "num_cols": 80209, "nnz": 307604} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Botonakis_FEM_3D_thermal2 (level: level3_large)\nShape: 147900 x 147900\nNon-zeros: 3489300 (avg nnz/row ≈ 23.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Botonakis_FEM_3D_thermal2.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Botonakis_FEM_3D_thermal2", "num_rows": 147900, "num_cols": 147900, "nnz": 3489300} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Botonakis_thermomech_TC (level: level3_large)\nShape: 102158 x 102158\nNon-zeros: 711558 (avg nnz/row ≈ 7.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Botonakis_thermomech_TC.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Botonakis_thermomech_TC", "num_rows": 102158, "num_cols": 102158, "nnz": 711558} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Botonakis_thermomech_dK (level: level3_large)\nShape: 204316 x 204316\nNon-zeros: 2846228 (avg nnz/row ≈ 13.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Botonakis_thermomech_dK.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Botonakis_thermomech_dK", "num_rows": 204316, "num_cols": 204316, "nnz": 2846228} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bova_rma10 (level: level3_large)\nShape: 46835 x 46835\nNon-zeros: 2374001 (avg nnz/row ≈ 50.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Bova_rma10.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Bova_rma10", "num_rows": 46835, "num_cols": 46835, "nnz": 2374001} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bydder_mri1 (level: level3_large)\nShape: 65536 x 147456\nNon-zeros: 589824 (avg nnz/row ≈ 9.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Bydder_mri1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Bydder_mri1", "num_rows": 65536, "num_cols": 147456, "nnz": 589824} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Castrillon_denormal (level: level3_large)\nShape: 89400 x 89400\nNon-zeros: 1156224 (avg nnz/row ≈ 12.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Castrillon_denormal.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Castrillon_denormal", "num_rows": 89400, "num_cols": 89400, "nnz": 1156224} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Chen_pkustk06 (level: level3_large)\nShape: 43164 x 43164\nNon-zeros: 2571768 (avg nnz/row ≈ 59.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Chen_pkustk06.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Chen_pkustk06", "num_rows": 43164, "num_cols": 43164, "nnz": 2571768} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Chen_pkustk09 (level: level3_large)\nShape: 33960 x 33960\nNon-zeros: 1583640 (avg nnz/row ≈ 46.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Chen_pkustk09.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Chen_pkustk09", "num_rows": 33960, "num_cols": 33960, "nnz": 1583640} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Chen_pkustk10 (level: level3_large)\nShape: 80676 x 80676\nNon-zeros: 4308984 (avg nnz/row ≈ 53.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Chen_pkustk10.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Chen_pkustk10", "num_rows": 80676, "num_cols": 80676, "nnz": 4308984} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Chen_pkustk11 (level: level3_large)\nShape: 87804 x 87804\nNon-zeros: 5217912 (avg nnz/row ≈ 59.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Chen_pkustk11.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Chen_pkustk11", "num_rows": 87804, "num_cols": 87804, "nnz": 5217912} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Clark_tomographic1 (level: level3_large)\nShape: 73159 x 59498\nNon-zeros: 647495 (avg nnz/row ≈ 8.9)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Clark_tomographic1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Clark_tomographic1", "num_rows": 73159, "num_cols": 59498, "nnz": 647495} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Cunningham_qa8fk (level: level3_large)\nShape: 66127 x 66127\nNon-zeros: 1660579 (avg nnz/row ≈ 25.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Cunningham_qa8fk.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Cunningham_qa8fk", "num_rows": 66127, "num_cols": 66127, "nnz": 1660579} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_G_n_pin_pout (level: level3_large)\nShape: 100000 x 100000\nNon-zeros: 1002396 (avg nnz/row ≈ 10.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_G_n_pin_pout.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_G_n_pin_pout", "num_rows": 100000, "num_cols": 100000, "nnz": 1002396} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_al2010 (level: level3_large)\nShape: 252266 x 252266\nNon-zeros: 1230482 (avg nnz/row ≈ 4.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_al2010.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_al2010", "num_rows": 252266, "num_cols": 252266, "nnz": 1230482} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_caidaRouterLevel (level: level3_large)\nShape: 192244 x 192244\nNon-zeros: 1218132 (avg nnz/row ≈ 6.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_caidaRouterLevel.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_caidaRouterLevel", "num_rows": 192244, "num_cols": 192244, "nnz": 1218132} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_coAuthorsCiteseer (level: level3_large)\nShape: 227320 x 227320\nNon-zeros: 1628268 (avg nnz/row ≈ 7.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_coAuthorsCiteseer.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_coAuthorsCiteseer", "num_rows": 227320, "num_cols": 227320, "nnz": 1628268} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_fe_body (level: level3_large)\nShape: 45087 x 45087\nNon-zeros: 327468 (avg nnz/row ≈ 7.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_fe_body.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_fe_body", "num_rows": 45087, "num_cols": 45087, "nnz": 327468} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_fe_rotor (level: level3_large)\nShape: 99617 x 99617\nNon-zeros: 1324862 (avg nnz/row ≈ 13.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_fe_rotor.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_fe_rotor", "num_rows": 99617, "num_cols": 99617, "nnz": 1324862} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_fe_tooth (level: level3_large)\nShape: 78136 x 78136\nNon-zeros: 905182 (avg nnz/row ≈ 11.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_fe_tooth.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_fe_tooth", "num_rows": 78136, "num_cols": 78136, "nnz": 905182} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_ia2010 (level: level3_large)\nShape: 216007 x 216007\nNon-zeros: 1021170 (avg nnz/row ≈ 4.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_ia2010.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_ia2010", "num_rows": 216007, "num_cols": 216007, "nnz": 1021170} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_luxembourg_osm (level: level3_large)\nShape: 114599 x 114599\nNon-zeros: 239332 (avg nnz/row ≈ 2.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_luxembourg_osm.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_luxembourg_osm", "num_rows": 114599, "num_cols": 114599, "nnz": 239332} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_md2010 (level: level3_large)\nShape: 145247 x 145247\nNon-zeros: 700378 (avg nnz/row ≈ 4.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_md2010.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_md2010", "num_rows": 145247, "num_cols": 145247, "nnz": 700378} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_nd2010 (level: level3_large)\nShape: 133769 x 133769\nNon-zeros: 625946 (avg nnz/row ≈ 4.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_nd2010.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_nd2010", "num_rows": 133769, "num_cols": 133769, "nnz": 625946} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_preferentialAttachment (level: level3_large)\nShape: 100000 x 100000\nNon-zeros: 999970 (avg nnz/row ≈ 10.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_preferentialAttachment.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_preferentialAttachment", "num_rows": 100000, "num_cols": 100000, "nnz": 999970} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_rgg_n_2_15_s0 (level: level3_large)\nShape: 32768 x 32768\nNon-zeros: 320480 (avg nnz/row ≈ 9.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_rgg_n_2_15_s0.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_rgg_n_2_15_s0", "num_rows": 32768, "num_cols": 32768, "nnz": 320480} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_rgg_n_2_16_s0 (level: level3_large)\nShape: 65536 x 65536\nNon-zeros: 684254 (avg nnz/row ≈ 10.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_rgg_n_2_16_s0.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_rgg_n_2_16_s0", "num_rows": 65536, "num_cols": 65536, "nnz": 684254} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_rgg_n_2_17_s0 (level: level3_large)\nShape: 131072 x 131072\nNon-zeros: 1457506 (avg nnz/row ≈ 11.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_rgg_n_2_17_s0.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_rgg_n_2_17_s0", "num_rows": 131072, "num_cols": 131072, "nnz": 1457506} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_rgg_n_2_18_s0 (level: level3_large)\nShape: 262144 x 262144\nNon-zeros: 3094566 (avg nnz/row ≈ 11.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_rgg_n_2_18_s0.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_rgg_n_2_18_s0", "num_rows": 262144, "num_cols": 262144, "nnz": 3094566} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_smallworld (level: level3_large)\nShape: 100000 x 100000\nNon-zeros: 999996 (avg nnz/row ≈ 10.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_smallworld.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_smallworld", "num_rows": 100000, "num_cols": 100000, "nnz": 999996} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_vsp_bcsstk30_500sep_10in_1Kout (level: level3_large)\nShape: 58348 x 58348\nNon-zeros: 4033156 (avg nnz/row ≈ 69.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_vsp_bcsstk30_500sep_10in_1Kout.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_vsp_bcsstk30_500sep_10in_1Kout", "num_rows": 58348, "num_cols": 58348, "nnz": 4033156} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_vsp_sctap1-2b_and_seymourl (level: level3_large)\nShape: 40174 x 40174\nNon-zeros: 281662 (avg nnz/row ≈ 7.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_vsp_sctap1-2b_and_seymourl.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_vsp_sctap1-2b_and_seymourl", "num_rows": 40174, "num_cols": 40174, "nnz": 281662} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_vsp_vibrobox_scagr7-2c_rlfddd (level: level3_large)\nShape: 77328 x 77328\nNon-zeros: 871172 (avg nnz/row ≈ 11.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DIMACS10_vsp_vibrobox_scagr7-2c_rlfddd.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DIMACS10_vsp_vibrobox_scagr7-2c_rlfddd", "num_rows": 77328, "num_cols": 77328, "nnz": 871172} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DNVS_ship_001 (level: level3_large)\nShape: 34920 x 34920\nNon-zeros: 4644230 (avg nnz/row ≈ 133.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DNVS_ship_001.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DNVS_ship_001", "num_rows": 34920, "num_cols": 34920, "nnz": 4644230} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DNVS_ship_003 (level: level3_large)\nShape: 121728 x 121728\nNon-zeros: 8086034 (avg nnz/row ≈ 66.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/DNVS_ship_003.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "DNVS_ship_003", "num_rows": 121728, "num_cols": 121728, "nnz": 8086034} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Dattorro_EternityII_E (level: level3_large)\nShape: 11077 x 262144\nNon-zeros: 1503732 (avg nnz/row ≈ 135.8)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Dattorro_EternityII_E.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Dattorro_EternityII_E", "num_rows": 11077, "num_cols": 262144, "nnz": 1503732} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Embree_ifiss_mat (level: level3_large)\nShape: 96307 x 96307\nNon-zeros: 3599932 (avg nnz/row ≈ 37.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Embree_ifiss_mat.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Embree_ifiss_mat", "num_rows": 96307, "num_cols": 96307, "nnz": 3599932} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FlowIPM22_uni_chimera_i3 (level: level3_large)\nShape: 100000 x 100000\nNon-zeros: 499696 (avg nnz/row ≈ 5.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/FlowIPM22_uni_chimera_i3.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "FlowIPM22_uni_chimera_i3", "num_rows": 100000, "num_cols": 100000, "nnz": 499696} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FlowIPM22_uni_chimera_i4 (level: level3_large)\nShape: 100000 x 100000\nNon-zeros: 814436 (avg nnz/row ≈ 8.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/FlowIPM22_uni_chimera_i4.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "FlowIPM22_uni_chimera_i4", "num_rows": 100000, "num_cols": 100000, "nnz": 814436} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FlowIPM22_uni_chimera_i5 (level: level3_large)\nShape: 100000 x 100000\nNon-zeros: 499982 (avg nnz/row ≈ 5.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/FlowIPM22_uni_chimera_i5.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "FlowIPM22_uni_chimera_i5", "num_rows": 100000, "num_cols": 100000, "nnz": 499982} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Fluorem_PR02R (level: level3_large)\nShape: 161070 x 161070\nNon-zeros: 8185136 (avg nnz/row ≈ 50.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Fluorem_PR02R.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Fluorem_PR02R", "num_rows": 161070, "num_cols": 161070, "nnz": 8185136} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_a0nsdsil (level: level3_large)\nShape: 80016 x 80016\nNon-zeros: 355034 (avg nnz/row ≈ 4.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_indef_a0nsdsil.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_indef_a0nsdsil", "num_rows": 80016, "num_cols": 80016, "nnz": 355034} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_aug3dcqp (level: level3_large)\nShape: 35543 x 35543\nNon-zeros: 128115 (avg nnz/row ≈ 3.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_indef_aug3dcqp.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_indef_aug3dcqp", "num_rows": 35543, "num_cols": 35543, "nnz": 128115} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_bmw3_2 (level: level3_large)\nShape: 227362 x 227362\nNon-zeros: 11288630 (avg nnz/row ≈ 49.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_indef_bmw3_2.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_indef_bmw3_2", "num_rows": 227362, "num_cols": 227362, "nnz": 11288630} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_c-58 (level: level3_large)\nShape: 37595 x 37595\nNon-zeros: 552557 (avg nnz/row ≈ 14.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_indef_c-58.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_indef_c-58", "num_rows": 37595, "num_cols": 37595, "nnz": 552557} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_c-63 (level: level3_large)\nShape: 44234 x 44234\nNon-zeros: 434704 (avg nnz/row ≈ 9.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_indef_c-63.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_indef_c-63", "num_rows": 44234, "num_cols": 44234, "nnz": 434704} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_c-68 (level: level3_large)\nShape: 64810 x 64810\nNon-zeros: 566006 (avg nnz/row ≈ 8.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_indef_c-68.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_indef_c-68", "num_rows": 64810, "num_cols": 64810, "nnz": 566006} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_c-70 (level: level3_large)\nShape: 68924 x 68924\nNon-zeros: 658986 (avg nnz/row ≈ 9.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_indef_c-70.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_indef_c-70", "num_rows": 68924, "num_cols": 68924, "nnz": 658986} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_c-72 (level: level3_large)\nShape: 84064 x 84064\nNon-zeros: 707558 (avg nnz/row ≈ 8.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_indef_c-72.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_indef_c-72", "num_rows": 84064, "num_cols": 84064, "nnz": 707558} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_dawson5 (level: level3_large)\nShape: 51537 x 51537\nNon-zeros: 1010777 (avg nnz/row ≈ 19.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_indef_dawson5.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_indef_dawson5", "num_rows": 51537, "num_cols": 51537, "nnz": 1010777} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_ncvxqp7 (level: level3_large)\nShape: 87500 x 87500\nNon-zeros: 574962 (avg nnz/row ≈ 6.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_indef_ncvxqp7.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_indef_ncvxqp7", "num_rows": 87500, "num_cols": 87500, "nnz": 574962} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_stokes128 (level: level3_large)\nShape: 49666 x 49666\nNon-zeros: 558594 (avg nnz/row ≈ 11.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_indef_stokes128.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_indef_stokes128", "num_rows": 49666, "num_cols": 49666, "nnz": 558594} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_psdef_bmw7st_1 (level: level3_large)\nShape: 141347 x 141347\nNon-zeros: 7339667 (avg nnz/row ≈ 51.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_psdef_bmw7st_1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_psdef_bmw7st_1", "num_rows": 141347, "num_cols": 141347, "nnz": 7339667} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_psdef_copter2 (level: level3_large)\nShape: 55476 x 55476\nNon-zeros: 759952 (avg nnz/row ≈ 13.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_psdef_copter2.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_psdef_copter2", "num_rows": 55476, "num_cols": 55476, "nnz": 759952} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_psdef_oilpan (level: level3_large)\nShape: 73752 x 73752\nNon-zeros: 3597188 (avg nnz/row ≈ 48.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_psdef_oilpan.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_psdef_oilpan", "num_rows": 73752, "num_cols": 73752, "nnz": 3597188} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_psdef_pwt (level: level3_large)\nShape: 36519 x 36519\nNon-zeros: 326107 (avg nnz/row ≈ 8.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_psdef_pwt.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_psdef_pwt", "num_rows": 36519, "num_cols": 36519, "nnz": 326107} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_psdef_torsion1 (level: level3_large)\nShape: 40000 x 40000\nNon-zeros: 197608 (avg nnz/row ≈ 4.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_psdef_torsion1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_psdef_torsion1", "num_rows": 40000, "num_cols": 40000, "nnz": 197608} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_psdef_wathen120 (level: level3_large)\nShape: 36441 x 36441\nNon-zeros: 565761 (avg nnz/row ≈ 15.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/GHS_psdef_wathen120.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "GHS_psdef_wathen120", "num_rows": 36441, "num_cols": 36441, "nnz": 565761} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gleich_usroads-48 (level: level3_large)\nShape: 126146 x 126146\nNon-zeros: 323900 (avg nnz/row ≈ 2.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Gleich_usroads-48.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Gleich_usroads-48", "num_rows": 126146, "num_cols": 126146, "nnz": 323900} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Gleich_usroads (level: level3_large)\nShape: 129164 x 129164\nNon-zeros: 330870 (avg nnz/row ≈ 2.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Gleich_usroads.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Gleich_usroads", "num_rows": 129164, "num_cols": 129164, "nnz": 330870} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Goodwin_Goodwin_054 (level: level3_large)\nShape: 32510 x 32510\nNon-zeros: 1030878 (avg nnz/row ≈ 31.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Goodwin_Goodwin_054.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Goodwin_Goodwin_054", "num_rows": 32510, "num_cols": 32510, "nnz": 1030878} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Goodwin_Goodwin_071 (level: level3_large)\nShape: 56021 x 56021\nNon-zeros: 1797934 (avg nnz/row ≈ 32.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Goodwin_Goodwin_071.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Goodwin_Goodwin_071", "num_rows": 56021, "num_cols": 56021, "nnz": 1797934} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Goodwin_Goodwin_127 (level: level3_large)\nShape: 178437 x 178437\nNon-zeros: 5778545 (avg nnz/row ≈ 32.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Goodwin_Goodwin_127.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Goodwin_Goodwin_127", "num_rows": 178437, "num_cols": 178437, "nnz": 5778545} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Grund_bayer01 (level: level3_large)\nShape: 57735 x 57735\nNon-zeros: 277774 (avg nnz/row ≈ 4.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Grund_bayer01.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Grund_bayer01", "num_rows": 57735, "num_cols": 57735, "nnz": 277774} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Grund_poli4 (level: level3_large)\nShape: 33833 x 33833\nNon-zeros: 73249 (avg nnz/row ≈ 2.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Grund_poli4.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Grund_poli4", "num_rows": 33833, "num_cols": 33833, "nnz": 73249} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Guettel_TEM152078 (level: level3_large)\nShape: 152078 x 152078\nNon-zeros: 6459326 (avg nnz/row ≈ 42.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Guettel_TEM152078.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Guettel_TEM152078", "num_rows": 152078, "num_cols": 152078, "nnz": 6459326} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Guettel_TEM181302 (level: level3_large)\nShape: 181302 x 181302\nNon-zeros: 7839010 (avg nnz/row ≈ 43.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Guettel_TEM181302.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Guettel_TEM181302", "num_rows": 181302, "num_cols": 181302, "nnz": 7839010} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hamm_bcircuit (level: level3_large)\nShape: 68902 x 68902\nNon-zeros: 375558 (avg nnz/row ≈ 5.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Hamm_bcircuit.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Hamm_bcircuit", "num_rows": 68902, "num_cols": 68902, "nnz": 375558} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hollinger_g7jac140sc (level: level3_large)\nShape: 41490 x 41490\nNon-zeros: 565956 (avg nnz/row ≈ 13.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Hollinger_g7jac140sc.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Hollinger_g7jac140sc", "num_rows": 41490, "num_cols": 41490, "nnz": 565956} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hollinger_g7jac160sc (level: level3_large)\nShape: 47430 x 47430\nNon-zeros: 656616 (avg nnz/row ≈ 13.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Hollinger_g7jac160sc.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Hollinger_g7jac160sc", "num_rows": 47430, "num_cols": 47430, "nnz": 656616} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hollinger_mark3jac100 (level: level3_large)\nShape: 45769 x 45769\nNon-zeros: 285215 (avg nnz/row ≈ 6.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Hollinger_mark3jac100.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Hollinger_mark3jac100", "num_rows": 45769, "num_cols": 45769, "nnz": 285215} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hollinger_mark3jac120sc (level: level3_large)\nShape: 54929 x 54929\nNon-zeros: 342475 (avg nnz/row ≈ 6.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Hollinger_mark3jac120sc.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Hollinger_mark3jac120sc", "num_rows": 54929, "num_cols": 54929, "nnz": 342475} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hollinger_mark3jac140 (level: level3_large)\nShape: 64089 x 64089\nNon-zeros: 399735 (avg nnz/row ≈ 6.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Hollinger_mark3jac140.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Hollinger_mark3jac140", "num_rows": 64089, "num_cols": 64089, "nnz": 399735} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: IPSO_HTC_336_9129 (level: level3_large)\nShape: 226340 x 226340\nNon-zeros: 883422 (avg nnz/row ≈ 3.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/IPSO_HTC_336_9129.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "IPSO_HTC_336_9129", "num_rows": 226340, "num_cols": 226340, "nnz": 883422} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: IPSO_OPF_10000 (level: level3_large)\nShape: 43887 x 43887\nNon-zeros: 467711 (avg nnz/row ≈ 10.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/IPSO_OPF_10000.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "IPSO_OPF_10000", "num_rows": 43887, "num_cols": 43887, "nnz": 467711} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_GL7d_GL7d23 (level: level3_large)\nShape: 105054 x 349443\nNon-zeros: 2695430 (avg nnz/row ≈ 25.7)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/JGD_GL7d_GL7d23.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "JGD_GL7d_GL7d23", "num_rows": 105054, "num_cols": 349443, "nnz": 2695430} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_GL7d_GL7d24 (level: level3_large)\nShape: 21074 x 105054\nNon-zeros: 593892 (avg nnz/row ≈ 28.2)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/JGD_GL7d_GL7d24.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "JGD_GL7d_GL7d24", "num_rows": 21074, "num_cols": 105054, "nnz": 593892} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Homology_n4c6-b10 (level: level3_large)\nShape: 132402 x 186558\nNon-zeros: 1456422 (avg nnz/row ≈ 11.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/JGD_Homology_n4c6-b10.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "JGD_Homology_n4c6-b10", "num_rows": 132402, "num_cols": 186558, "nnz": 1456422} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Homology_n4c6-b12 (level: level3_large)\nShape: 25605 x 69235\nNon-zeros: 332865 (avg nnz/row ≈ 13.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/JGD_Homology_n4c6-b12.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "JGD_Homology_n4c6-b12", "num_rows": 25605, "num_cols": 69235, "nnz": 332865} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Homology_n4c6-b5 (level: level3_large)\nShape: 51813 x 20058\nNon-zeros: 310878 (avg nnz/row ≈ 6.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/JGD_Homology_n4c6-b5.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "JGD_Homology_n4c6-b5", "num_rows": 51813, "num_cols": 20058, "nnz": 310878} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Homology_n4c6-b6 (level: level3_large)\nShape: 104115 x 51813\nNon-zeros: 728805 (avg nnz/row ≈ 7.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/JGD_Homology_n4c6-b6.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "JGD_Homology_n4c6-b6", "num_rows": 104115, "num_cols": 51813, "nnz": 728805} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Homology_n4c6-b9 (level: level3_large)\nShape: 186558 x 198895\nNon-zeros: 1865580 (avg nnz/row ≈ 10.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/JGD_Homology_n4c6-b9.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "JGD_Homology_n4c6-b9", "num_rows": 186558, "num_cols": 198895, "nnz": 1865580} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Homology_shar_te2-b2 (level: level3_large)\nShape: 200200 x 17160\nNon-zeros: 600600 (avg nnz/row ≈ 3.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/JGD_Homology_shar_te2-b2.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "JGD_Homology_shar_te2-b2", "num_rows": 200200, "num_cols": 17160, "nnz": 600600} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Homology_shar_te2-b3 (level: level3_large)\nShape: 200200 x 200200\nNon-zeros: 800800 (avg nnz/row ≈ 4.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/JGD_Homology_shar_te2-b3.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "JGD_Homology_shar_te2-b3", "num_rows": 200200, "num_cols": 200200, "nnz": 800800} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Kamvar_Stanford (level: level3_large)\nShape: 281903 x 281903\nNon-zeros: 2312497 (avg nnz/row ≈ 8.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Kamvar_Stanford.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Kamvar_Stanford", "num_rows": 281903, "num_cols": 281903, "nnz": 2312497} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Kim_kim1 (level: level3_large)\nShape: 38415 x 38415\nNon-zeros: 933195 (avg nnz/row ≈ 24.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Kim_kim1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Kim_kim1", "num_rows": 38415, "num_cols": 38415, "nnz": 933195} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: LAW_enron (level: level3_large)\nShape: 69244 x 69244\nNon-zeros: 276143 (avg nnz/row ≈ 4.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/LAW_enron.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "LAW_enron", "num_rows": 69244, "num_cols": 69244, "nnz": 276143} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ML_Graph_k49_norm_10NN (level: level3_large)\nShape: 38547 x 38547\nNon-zeros: 618158 (avg nnz/row ≈ 16.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/ML_Graph_k49_norm_10NN.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "ML_Graph_k49_norm_10NN", "num_rows": 38547, "num_cols": 38547, "nnz": 618158} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr34 (level: level3_large)\nShape: 35152 x 35152\nNon-zeros: 764014 (avg nnz/row ≈ 21.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Mallya_lhr34.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Mallya_lhr34", "num_rows": 35152, "num_cols": 35152, "nnz": 764014} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr34c (level: level3_large)\nShape: 35152 x 35152\nNon-zeros: 764014 (avg nnz/row ≈ 21.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Mallya_lhr34c.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Mallya_lhr34c", "num_rows": 35152, "num_cols": 35152, "nnz": 764014} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr71 (level: level3_large)\nShape: 70304 x 70304\nNon-zeros: 1528092 (avg nnz/row ≈ 21.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Mallya_lhr71.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Mallya_lhr71", "num_rows": 70304, "num_cols": 70304, "nnz": 1528092} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mallya_lhr71c (level: level3_large)\nShape: 70304 x 70304\nNon-zeros: 1528092 (avg nnz/row ≈ 21.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Mallya_lhr71c.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Mallya_lhr71c", "num_rows": 70304, "num_cols": 70304, "nnz": 1528092} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mancktelow_viscorocks (level: level3_large)\nShape: 37762 x 37762\nNon-zeros: 1162244 (avg nnz/row ≈ 30.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Mancktelow_viscorocks.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Mancktelow_viscorocks", "num_rows": 37762, "num_cols": 37762, "nnz": 1162244} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: MaxPlanck_shallow_water1 (level: level3_large)\nShape: 81920 x 81920\nNon-zeros: 327680 (avg nnz/row ≈ 4.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/MaxPlanck_shallow_water1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "MaxPlanck_shallow_water1", "num_rows": 81920, "num_cols": 81920, "nnz": 327680} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: McRae_ecology1 (level: level3_large)\nShape: 1000000 x 1000000\nNon-zeros: 4996000 (avg nnz/row ≈ 5.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/McRae_ecology1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "McRae_ecology1", "num_rows": 1000000, "num_cols": 1000000, "nnz": 4996000} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_fxm3_16 (level: level3_large)\nShape: 41340 x 85575\nNon-zeros: 392252 (avg nnz/row ≈ 9.5)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Meszaros_fxm3_16.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Meszaros_fxm3_16", "num_rows": 41340, "num_cols": 85575, "nnz": 392252} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_fxm4_6 (level: level3_large)\nShape: 22400 x 47185\nNon-zeros: 265442 (avg nnz/row ≈ 11.9)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Meszaros_fxm4_6.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Meszaros_fxm4_6", "num_rows": 22400, "num_cols": 47185, "nnz": 265442} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_karted (level: level3_large)\nShape: 46502 x 133115\nNon-zeros: 1770349 (avg nnz/row ≈ 38.1)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Meszaros_karted.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Meszaros_karted", "num_rows": 46502, "num_cols": 133115, "nnz": 1770349} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_pltexpa (level: level3_large)\nShape: 26894 x 70364\nNon-zeros: 143059 (avg nnz/row ≈ 5.3)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Meszaros_pltexpa.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Meszaros_pltexpa", "num_rows": 26894, "num_cols": 70364, "nnz": 143059} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_rlfprim (level: level3_large)\nShape: 58866 x 62716\nNon-zeros: 320591 (avg nnz/row ≈ 5.4)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Meszaros_rlfprim.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Meszaros_rlfprim", "num_rows": 58866, "num_cols": 62716, "nnz": 320591} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_stat96v3 (level: level3_large)\nShape: 33841 x 1113780\nNon-zeros: 3317736 (avg nnz/row ≈ 98.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Meszaros_stat96v3.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Meszaros_stat96v3", "num_rows": 33841, "num_cols": 1113780, "nnz": 3317736} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mittelmann_fome12 (level: level3_large)\nShape: 24284 x 48920\nNon-zeros: 142528 (avg nnz/row ≈ 5.9)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Mittelmann_fome12.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Mittelmann_fome12", "num_rows": 24284, "num_cols": 48920, "nnz": 142528} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mittelmann_watson_1 (level: level3_large)\nShape: 201155 x 386992\nNon-zeros: 1055093 (avg nnz/row ≈ 5.2)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Mittelmann_watson_1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Mittelmann_watson_1", "num_rows": 201155, "num_cols": 386992, "nnz": 1055093} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Muite_Chebyshev4 (level: level3_large)\nShape: 68121 x 68121\nNon-zeros: 5377761 (avg nnz/row ≈ 78.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Muite_Chebyshev4.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Muite_Chebyshev4", "num_rows": 68121, "num_cols": 68121, "nnz": 5377761} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Mulvey_pfinan512 (level: level3_large)\nShape: 74752 x 74752\nNon-zeros: 596992 (avg nnz/row ≈ 8.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Mulvey_pfinan512.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Mulvey_pfinan512", "num_rows": 74752, "num_cols": 74752, "nnz": 596992} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: NYPA_Maragal_7 (level: level3_large)\nShape: 46845 x 26564\nNon-zeros: 1200537 (avg nnz/row ≈ 25.6)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/NYPA_Maragal_7.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "NYPA_Maragal_7", "num_rows": 46845, "num_cols": 26564, "nnz": 1200537} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: NYPA_Maragal_8 (level: level3_large)\nShape: 33212 x 75077\nNon-zeros: 1308415 (avg nnz/row ≈ 39.4)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/NYPA_Maragal_8.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "NYPA_Maragal_8", "num_rows": 33212, "num_cols": 75077, "nnz": 1308415} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Nasa_pwt (level: level3_large)\nShape: 36519 x 36519\nNon-zeros: 326107 (avg nnz/row ≈ 8.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Nasa_pwt.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Nasa_pwt", "num_rows": 36519, "num_cols": 36519, "nnz": 326107} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Newman_cond-mat-2005 (level: level3_large)\nShape: 40421 x 40421\nNon-zeros: 351386 (avg nnz/row ≈ 8.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Newman_cond-mat-2005.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Newman_cond-mat-2005", "num_rows": 40421, "num_cols": 40421, "nnz": 351386} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Norris_lung2 (level: level3_large)\nShape: 109460 x 109460\nNon-zeros: 492564 (avg nnz/row ≈ 4.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Norris_lung2.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Norris_lung2", "num_rows": 109460, "num_cols": 109460, "nnz": 492564} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Norris_torso3 (level: level3_large)\nShape: 259156 x 259156\nNon-zeros: 4429042 (avg nnz/row ≈ 17.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Norris_torso3.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Norris_torso3", "num_rows": 259156, "num_cols": 259156, "nnz": 4429042} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_boneS01 (level: level3_large)\nShape: 127224 x 127224\nNon-zeros: 6715152 (avg nnz/row ≈ 52.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Oberwolfach_boneS01.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Oberwolfach_boneS01", "num_rows": 127224, "num_cols": 127224, "nnz": 6715152} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_gas_sensor (level: level3_large)\nShape: 66917 x 66917\nNon-zeros: 1703365 (avg nnz/row ≈ 25.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Oberwolfach_gas_sensor.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Oberwolfach_gas_sensor", "num_rows": 66917, "num_cols": 66917, "nnz": 1703365} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_rail_79841 (level: level3_large)\nShape: 79841 x 79841\nNon-zeros: 553921 (avg nnz/row ≈ 6.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Oberwolfach_rail_79841.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Oberwolfach_rail_79841", "num_rows": 79841, "num_cols": 79841, "nnz": 553921} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_t3dh (level: level3_large)\nShape: 79171 x 79171\nNon-zeros: 4352105 (avg nnz/row ≈ 55.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Oberwolfach_t3dh.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Oberwolfach_t3dh", "num_rows": 79171, "num_cols": 79171, "nnz": 4352105} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Oberwolfach_t3dh_a (level: level3_large)\nShape: 79171 x 79171\nNon-zeros: 4352105 (avg nnz/row ≈ 55.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Oberwolfach_t3dh_a.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Oberwolfach_t3dh_a", "num_rows": 79171, "num_cols": 79171, "nnz": 4352105} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_CO (level: level3_large)\nShape: 221119 x 221119\nNon-zeros: 7666057 (avg nnz/row ≈ 34.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/PARSEC_CO.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "PARSEC_CO", "num_rows": 221119, "num_cols": 221119, "nnz": 7666057} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_Ga10As10H30 (level: level3_large)\nShape: 113081 x 113081\nNon-zeros: 6115633 (avg nnz/row ≈ 54.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/PARSEC_Ga10As10H30.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "PARSEC_Ga10As10H30", "num_rows": 113081, "num_cols": 113081, "nnz": 6115633} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_Ga19As19H42 (level: level3_large)\nShape: 133123 x 133123\nNon-zeros: 8884839 (avg nnz/row ≈ 66.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/PARSEC_Ga19As19H42.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "PARSEC_Ga19As19H42", "num_rows": 133123, "num_cols": 133123, "nnz": 8884839} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_Ge99H100 (level: level3_large)\nShape: 112985 x 112985\nNon-zeros: 8451395 (avg nnz/row ≈ 74.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/PARSEC_Ge99H100.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "PARSEC_Ge99H100", "num_rows": 112985, "num_cols": 112985, "nnz": 8451395} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_H2O (level: level3_large)\nShape: 67024 x 67024\nNon-zeros: 2216736 (avg nnz/row ≈ 33.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/PARSEC_H2O.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "PARSEC_H2O", "num_rows": 67024, "num_cols": 67024, "nnz": 2216736} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_Si34H36 (level: level3_large)\nShape: 97569 x 97569\nNon-zeros: 5156379 (avg nnz/row ≈ 52.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/PARSEC_Si34H36.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "PARSEC_Si34H36", "num_rows": 97569, "num_cols": 97569, "nnz": 5156379} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PARSEC_SiO (level: level3_large)\nShape: 33401 x 33401\nNon-zeros: 1317655 (avg nnz/row ≈ 39.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/PARSEC_SiO.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "PARSEC_SiO", "num_rows": 33401, "num_cols": 33401, "nnz": 1317655} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pothen_pwt (level: level3_large)\nShape: 36519 x 36519\nNon-zeros: 326107 (avg nnz/row ≈ 8.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Pothen_pwt.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Pothen_pwt", "num_rows": 36519, "num_cols": 36519, "nnz": 326107} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pothen_tandem_dual (level: level3_large)\nShape: 94069 x 94069\nNon-zeros: 460493 (avg nnz/row ≈ 4.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Pothen_tandem_dual.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Pothen_tandem_dual", "num_rows": 94069, "num_cols": 94069, "nnz": 460493} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: PowerSystem_power197k (level: level3_large)\nShape: 197156 x 197156\nNon-zeros: 3698357 (avg nnz/row ≈ 18.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/PowerSystem_power197k.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "PowerSystem_power197k", "num_rows": 197156, "num_cols": 197156, "nnz": 3698357} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Qaplib_lp_nug30 (level: level3_large)\nShape: 52260 x 379350\nNon-zeros: 1567800 (avg nnz/row ≈ 30.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Qaplib_lp_nug30.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Qaplib_lp_nug30", "num_rows": 52260, "num_cols": 379350, "nnz": 1567800} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Quaglino_viscoplastic2 (level: level3_large)\nShape: 32769 x 32769\nNon-zeros: 381326 (avg nnz/row ≈ 11.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Quaglino_viscoplastic2.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Quaglino_viscoplastic2", "num_rows": 32769, "num_cols": 32769, "nnz": 381326} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Rajat_rajat15 (level: level3_large)\nShape: 37261 x 37261\nNon-zeros: 443573 (avg nnz/row ≈ 11.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Rajat_rajat15.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Rajat_rajat15", "num_rows": 37261, "num_cols": 37261, "nnz": 443573} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Rajat_rajat20 (level: level3_large)\nShape: 86916 x 86916\nNon-zeros: 605045 (avg nnz/row ≈ 7.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Rajat_rajat20.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Rajat_rajat20", "num_rows": 86916, "num_cols": 86916, "nnz": 605045} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Rajat_rajat23 (level: level3_large)\nShape: 110355 x 110355\nNon-zeros: 556938 (avg nnz/row ≈ 5.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Rajat_rajat23.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Rajat_rajat23", "num_rows": 110355, "num_cols": 110355, "nnz": 556938} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Raju_laminar_duct3D (level: level3_large)\nShape: 67173 x 67173\nNon-zeros: 3833077 (avg nnz/row ≈ 57.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Raju_laminar_duct3D.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Raju_laminar_duct3D", "num_rows": 67173, "num_cols": 67173, "nnz": 3833077} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Rommes_bauru5727 (level: level3_large)\nShape: 40366 x 40366\nNon-zeros: 145019 (avg nnz/row ≈ 3.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Rommes_bauru5727.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Rommes_bauru5727", "num_rows": 40366, "num_cols": 40366, "nnz": 145019} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Rommes_juba40k (level: level3_large)\nShape: 40337 x 40337\nNon-zeros: 144945 (avg nnz/row ≈ 3.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Rommes_juba40k.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Rommes_juba40k", "num_rows": 40337, "num_cols": 40337, "nnz": 144945} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Rothberg_3dtube (level: level3_large)\nShape: 45330 x 45330\nNon-zeros: 3213618 (avg nnz/row ≈ 70.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Rothberg_3dtube.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Rothberg_3dtube", "num_rows": 45330, "num_cols": 45330, "nnz": 3213618} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Rothberg_cfd1 (level: level3_large)\nShape: 70656 x 70656\nNon-zeros: 1828364 (avg nnz/row ≈ 25.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Rothberg_cfd1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Rothberg_cfd1", "num_rows": 70656, "num_cols": 70656, "nnz": 1828364} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Rothberg_gearbox (level: level3_large)\nShape: 153746 x 153746\nNon-zeros: 9080404 (avg nnz/row ≈ 59.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Rothberg_gearbox.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Rothberg_gearbox", "num_rows": 153746, "num_cols": 153746, "nnz": 9080404} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_email-Enron (level: level3_large)\nShape: 36692 x 36692\nNon-zeros: 367662 (avg nnz/row ≈ 10.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_email-Enron.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_email-Enron", "num_rows": 36692, "num_cols": 36692, "nnz": 367662} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_loc-Brightkite (level: level3_large)\nShape: 58228 x 58228\nNon-zeros: 428156 (avg nnz/row ≈ 7.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_loc-Brightkite.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_loc-Brightkite", "num_rows": 58228, "num_cols": 58228, "nnz": 428156} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_loc-Gowalla (level: level3_large)\nShape: 196591 x 196591\nNon-zeros: 1900654 (avg nnz/row ≈ 9.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_loc-Gowalla.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_loc-Gowalla", "num_rows": 196591, "num_cols": 196591, "nnz": 1900654} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_p2p-Gnutella31 (level: level3_large)\nShape: 62586 x 62586\nNon-zeros: 147892 (avg nnz/row ≈ 2.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_p2p-Gnutella31.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_p2p-Gnutella31", "num_rows": 62586, "num_cols": 62586, "nnz": 147892} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_soc-Epinions1 (level: level3_large)\nShape: 75888 x 75888\nNon-zeros: 508837 (avg nnz/row ≈ 6.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_soc-Epinions1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_soc-Epinions1", "num_rows": 75888, "num_cols": 75888, "nnz": 508837} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_soc-Slashdot0811 (level: level3_large)\nShape: 77360 x 77360\nNon-zeros: 905468 (avg nnz/row ≈ 11.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_soc-Slashdot0811.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_soc-Slashdot0811", "num_rows": 77360, "num_cols": 77360, "nnz": 905468} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_soc-Slashdot0902 (level: level3_large)\nShape: 82168 x 82168\nNon-zeros: 948464 (avg nnz/row ≈ 11.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_soc-Slashdot0902.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_soc-Slashdot0902", "num_rows": 82168, "num_cols": 82168, "nnz": 948464} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_soc-sign-Slashdot081106 (level: level3_large)\nShape: 77357 x 77357\nNon-zeros: 516575 (avg nnz/row ≈ 6.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_soc-sign-Slashdot081106.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_soc-sign-Slashdot081106", "num_rows": 77357, "num_cols": 77357, "nnz": 516575} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_soc-sign-Slashdot090216 (level: level3_large)\nShape: 81871 x 81871\nNon-zeros: 545671 (avg nnz/row ≈ 6.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_soc-sign-Slashdot090216.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_soc-sign-Slashdot090216", "num_rows": 81871, "num_cols": 81871, "nnz": 545671} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_soc-sign-Slashdot090221 (level: level3_large)\nShape: 82144 x 82144\nNon-zeros: 549202 (avg nnz/row ≈ 6.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_soc-sign-Slashdot090221.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_soc-sign-Slashdot090221", "num_rows": 82144, "num_cols": 82144, "nnz": 549202} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_soc-sign-epinions (level: level3_large)\nShape: 131828 x 131828\nNon-zeros: 841372 (avg nnz/row ≈ 6.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_soc-sign-epinions.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_soc-sign-epinions", "num_rows": 131828, "num_cols": 131828, "nnz": 841372} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_sx-superuser (level: level3_large)\nShape: 194085 x 194085\nNon-zeros: 924886 (avg nnz/row ≈ 4.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/SNAP_sx-superuser.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "SNAP_sx-superuser", "num_rows": 194085, "num_cols": 194085, "nnz": 924886} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Sanghavi_ecl32 (level: level3_large)\nShape: 51993 x 51993\nNon-zeros: 380415 (avg nnz/row ≈ 7.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Sanghavi_ecl32.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Sanghavi_ecl32", "num_rows": 51993, "num_cols": 51993, "nnz": 380415} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-57 (level: level3_large)\nShape: 37833 x 37833\nNon-zeros: 405197 (avg nnz/row ≈ 10.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_IBMNA_c-57.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_IBMNA_c-57", "num_rows": 37833, "num_cols": 37833, "nnz": 405197} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-60 (level: level3_large)\nShape: 43640 x 43640\nNon-zeros: 298578 (avg nnz/row ≈ 6.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_IBMNA_c-60.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_IBMNA_c-60", "num_rows": 43640, "num_cols": 43640, "nnz": 298578} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-61 (level: level3_large)\nShape: 43618 x 43618\nNon-zeros: 310016 (avg nnz/row ≈ 7.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_IBMNA_c-61.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_IBMNA_c-61", "num_rows": 43618, "num_cols": 43618, "nnz": 310016} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-62 (level: level3_large)\nShape: 41731 x 41731\nNon-zeros: 559343 (avg nnz/row ≈ 13.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_IBMNA_c-62.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_IBMNA_c-62", "num_rows": 41731, "num_cols": 41731, "nnz": 559343} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-66 (level: level3_large)\nShape: 49989 x 49989\nNon-zeros: 499007 (avg nnz/row ≈ 10.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_IBMNA_c-66.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_IBMNA_c-66", "num_rows": 49989, "num_cols": 49989, "nnz": 499007} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-66b (level: level3_large)\nShape: 49989 x 49989\nNon-zeros: 499007 (avg nnz/row ≈ 10.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_IBMNA_c-66b.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_IBMNA_c-66b", "num_rows": 49989, "num_cols": 49989, "nnz": 499007} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-67 (level: level3_large)\nShape: 57975 x 57975\nNon-zeros: 531935 (avg nnz/row ≈ 9.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_IBMNA_c-67.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_IBMNA_c-67", "num_rows": 57975, "num_cols": 57975, "nnz": 531935} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMNA_c-67b (level: level3_large)\nShape: 57975 x 57975\nNon-zeros: 531935 (avg nnz/row ≈ 9.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_IBMNA_c-67b.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_IBMNA_c-67b", "num_rows": 57975, "num_cols": 57975, "nnz": 531935} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMSDS_2D_54019_highK (level: level3_large)\nShape: 54019 x 54019\nNon-zeros: 996414 (avg nnz/row ≈ 18.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_IBMSDS_2D_54019_highK.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_IBMSDS_2D_54019_highK", "num_rows": 54019, "num_cols": 54019, "nnz": 996414} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_IBMSDS_matrix-new_3 (level: level3_large)\nShape: 125329 x 125329\nNon-zeros: 2678750 (avg nnz/row ≈ 21.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_IBMSDS_matrix-new_3.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_IBMSDS_matrix-new_3", "num_rows": 125329, "num_cols": 125329, "nnz": 2678750} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_ISEI_barrier2-9 (level: level3_large)\nShape: 115625 x 115625\nNon-zeros: 3897557 (avg nnz/row ≈ 33.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_ISEI_barrier2-9.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_ISEI_barrier2-9", "num_rows": 115625, "num_cols": 115625, "nnz": 3897557} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_ISEI_ohne2 (level: level3_large)\nShape: 181343 x 181343\nNon-zeros: 11063545 (avg nnz/row ≈ 61.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_ISEI_ohne2.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_ISEI_ohne2", "num_rows": 181343, "num_cols": 181343, "nnz": 11063545} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_ISEI_para-10 (level: level3_large)\nShape: 155924 x 155924\nNon-zeros: 5416358 (avg nnz/row ≈ 34.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_ISEI_para-10.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_ISEI_para-10", "num_rows": 155924, "num_cols": 155924, "nnz": 5416358} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_ISEI_para-4 (level: level3_large)\nShape: 153226 x 153226\nNon-zeros: 5326228 (avg nnz/row ≈ 34.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_ISEI_para-4.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_ISEI_para-4", "num_rows": 153226, "num_cols": 153226, "nnz": 5326228} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_ISEI_para-9 (level: level3_large)\nShape: 155924 x 155924\nNon-zeros: 5416358 (avg nnz/row ≈ 34.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schenk_ISEI_para-9.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schenk_ISEI_para-9", "num_rows": 155924, "num_cols": 155924, "nnz": 5416358} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schmid_thermal1 (level: level3_large)\nShape: 82654 x 82654\nNon-zeros: 574458 (avg nnz/row ≈ 7.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Schmid_thermal1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Schmid_thermal1", "num_rows": 82654, "num_cols": 82654, "nnz": 574458} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Simon_bbmat (level: level3_large)\nShape: 38744 x 38744\nNon-zeros: 1771722 (avg nnz/row ≈ 45.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Simon_bbmat.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Simon_bbmat", "num_rows": 38744, "num_cols": 38744, "nnz": 1771722} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Simon_venkat25 (level: level3_large)\nShape: 62424 x 62424\nNon-zeros: 1717792 (avg nnz/row ≈ 27.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Simon_venkat25.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Simon_venkat25", "num_rows": 62424, "num_cols": 62424, "nnz": 1717792} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TKK_engine (level: level3_large)\nShape: 143571 x 143571\nNon-zeros: 4706073 (avg nnz/row ≈ 32.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/TKK_engine.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "TKK_engine", "num_rows": 143571, "num_cols": 143571, "nnz": 4706073} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b2383 (level: level3_large)\nShape: 38120 x 38120\nNon-zeros: 16171169 (avg nnz/row ≈ 424.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/TSOPF_TSOPF_RS_b2383.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "TSOPF_TSOPF_RS_b2383", "num_rows": 38120, "num_cols": 38120, "nnz": 16171169} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b39_c30 (level: level3_large)\nShape: 60098 x 60098\nNon-zeros: 1079986 (avg nnz/row ≈ 18.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/TSOPF_TSOPF_RS_b39_c30.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "TSOPF_TSOPF_RS_b39_c30", "num_rows": 60098, "num_cols": 60098, "nnz": 1079986} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: TSOPF_TSOPF_RS_b678_c2 (level: level3_large)\nShape: 35696 x 35696\nNon-zeros: 8781949 (avg nnz/row ≈ 246.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/TSOPF_TSOPF_RS_b678_c2.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "TSOPF_TSOPF_RS_b678_c2", "num_rows": 35696, "num_cols": 35696, "nnz": 8781949} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Toledo_deltaX (level: level3_large)\nShape: 68600 x 21961\nNon-zeros: 247424 (avg nnz/row ≈ 3.6)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Toledo_deltaX.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Toledo_deltaX", "num_rows": 68600, "num_cols": 21961, "nnz": 247424} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: UTEP_Dubcova2 (level: level3_large)\nShape: 65025 x 65025\nNon-zeros: 1030225 (avg nnz/row ≈ 15.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/UTEP_Dubcova2.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "UTEP_Dubcova2", "num_rows": 65025, "num_cols": 65025, "nnz": 1030225} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: UTEP_Dubcova3 (level: level3_large)\nShape: 146689 x 146689\nNon-zeros: 3636649 (avg nnz/row ≈ 24.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/UTEP_Dubcova3.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "UTEP_Dubcova3", "num_rows": 146689, "num_cols": 146689, "nnz": 3636649} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Um_offshore (level: level3_large)\nShape: 259789 x 259789\nNon-zeros: 4242673 (avg nnz/row ≈ 16.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Um_offshore.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Um_offshore", "num_rows": 259789, "num_cols": 259789, "nnz": 4242673} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VLSI_nv1 (level: level3_large)\nShape: 75468 x 75468\nNon-zeros: 2449194 (avg nnz/row ≈ 32.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/VLSI_nv1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "VLSI_nv1", "num_rows": 75468, "num_cols": 75468, "nnz": 2449194} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VLSI_power9 (level: level3_large)\nShape: 155376 x 155376\nNon-zeros: 2512300 (avg nnz/row ≈ 16.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/VLSI_power9.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "VLSI_power9", "num_rows": 155376, "num_cols": 155376, "nnz": 2512300} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VLSI_radiation (level: level3_large)\nShape: 223104 x 223104\nNon-zeros: 7637688 (avg nnz/row ≈ 34.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/VLSI_radiation.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "VLSI_radiation", "num_rows": 223104, "num_cols": 223104, "nnz": 7637688} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VLSI_ss1 (level: level3_large)\nShape: 205282 x 205282\nNon-zeros: 845089 (avg nnz/row ≈ 4.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/VLSI_ss1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "VLSI_ss1", "num_rows": 205282, "num_cols": 205282, "nnz": 845089} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Vavasis_av41092 (level: level3_large)\nShape: 41092 x 41092\nNon-zeros: 1683902 (avg nnz/row ≈ 41.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Vavasis_av41092.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Vavasis_av41092", "num_rows": 41092, "num_cols": 41092, "nnz": 1683902} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Williams_cant (level: level3_large)\nShape: 62451 x 62451\nNon-zeros: 4007383 (avg nnz/row ≈ 64.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Williams_cant.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Williams_cant", "num_rows": 62451, "num_cols": 62451, "nnz": 4007383} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Williams_consph (level: level3_large)\nShape: 83334 x 83334\nNon-zeros: 6010480 (avg nnz/row ≈ 72.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Williams_consph.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Williams_consph", "num_rows": 83334, "num_cols": 83334, "nnz": 6010480} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Williams_mac_econ_fwd500 (level: level3_large)\nShape: 206500 x 206500\nNon-zeros: 1273389 (avg nnz/row ≈ 6.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Williams_mac_econ_fwd500.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Williams_mac_econ_fwd500", "num_rows": 206500, "num_cols": 206500, "nnz": 1273389} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Williams_pdb1HYS (level: level3_large)\nShape: 36417 x 36417\nNon-zeros: 4344765 (avg nnz/row ≈ 119.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Williams_pdb1HYS.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Williams_pdb1HYS", "num_rows": 36417, "num_cols": 36417, "nnz": 4344765} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Yoshiyasu_image_interp (level: level3_large)\nShape: 240000 x 120000\nNon-zeros: 711683 (avg nnz/row ≈ 3.0)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Yoshiyasu_image_interp.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Yoshiyasu_image_interp", "num_rows": 240000, "num_cols": 120000, "nnz": 711683} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Zhao_Zhao1 (level: level3_large)\nShape: 33861 x 33861\nNon-zeros: 166453 (avg nnz/row ≈ 4.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/Zhao_Zhao1.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "Zhao_Zhao1", "num_rows": 33861, "num_cols": 33861, "nnz": 166453} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: vanHeukelum_cage11 (level: level3_large)\nShape: 39082 x 39082\nNon-zeros: 559722 (avg nnz/row ≈ 14.3)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/vanHeukelum_cage11.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "vanHeukelum_cage11", "num_rows": 39082, "num_cols": 39082, "nnz": 559722} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: vanHeukelum_cage12 (level: level3_large)\nShape: 130228 x 130228\nNon-zeros: 2032536 (avg nnz/row ≈ 15.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level3_large/vanHeukelum_cage12.bin", "op_type": "spgemm", "K": 0, "level": "level3_large", "matrix_name": "vanHeukelum_cage12", "num_rows": 130228, "num_cols": 130228, "nnz": 2032536} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: AG-Monien_debr (level: level4_huge)\nShape: 1048576 x 1048576\nNon-zeros: 4194298 (avg nnz/row ≈ 4.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/AG-Monien_debr.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "AG-Monien_debr", "num_rows": 1048576, "num_cols": 1048576, "nnz": 4194298} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ANSYS_Delor338K (level: level4_huge)\nShape: 343236 x 887058\nNon-zeros: 4211599 (avg nnz/row ≈ 12.3)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/ANSYS_Delor338K.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "ANSYS_Delor338K", "num_rows": 343236, "num_cols": 887058, "nnz": 4211599} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ANSYS_Delor64K (level: level4_huge)\nShape: 64719 x 1785345\nNon-zeros: 652140 (avg nnz/row ≈ 10.1)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/ANSYS_Delor64K.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "ANSYS_Delor64K", "num_rows": 64719, "num_cols": 1785345, "nnz": 652140} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: ATandT_pre2 (level: level4_huge)\nShape: 659033 x 659033\nNon-zeros: 5959282 (avg nnz/row ≈ 9.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/ATandT_pre2.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "ATandT_pre2", "num_rows": 659033, "num_cols": 659033, "nnz": 5959282} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Bourchtein_atmosmodd (level: level4_huge)\nShape: 1270432 x 1270432\nNon-zeros: 8814880 (avg nnz/row ≈ 6.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Bourchtein_atmosmodd.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Bourchtein_atmosmodd", "num_rows": 1270432, "num_cols": 1270432, "nnz": 8814880} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: CEMW_tmt_unsym (level: level4_huge)\nShape: 917825 x 917825\nNon-zeros: 4584801 (avg nnz/row ≈ 5.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/CEMW_tmt_unsym.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "CEMW_tmt_unsym", "num_rows": 917825, "num_cols": 917825, "nnz": 4584801} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_NACA0015 (level: level4_huge)\nShape: 1039183 x 1039183\nNon-zeros: 6229636 (avg nnz/row ≈ 6.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/DIMACS10_NACA0015.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "DIMACS10_NACA0015", "num_rows": 1039183, "num_cols": 1039183, "nnz": 6229636} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_auto (level: level4_huge)\nShape: 448695 x 448695\nNon-zeros: 6629222 (avg nnz/row ≈ 14.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/DIMACS10_auto.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "DIMACS10_auto", "num_rows": 448695, "num_cols": 448695, "nnz": 6629222} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_delaunay_n24 (level: level4_huge)\nShape: 16777216 x 16777216\nNon-zeros: 100663202 (avg nnz/row ≈ 6.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/DIMACS10_delaunay_n24.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "DIMACS10_delaunay_n24", "num_rows": 16777216, "num_cols": 16777216, "nnz": 100663202} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: DIMACS10_ny2010 (level: level4_huge)\nShape: 350169 x 350169\nNon-zeros: 1709544 (avg nnz/row ≈ 4.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/DIMACS10_ny2010.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "DIMACS10_ny2010", "num_rows": 350169, "num_cols": 350169, "nnz": 1709544} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: FlowIPM22_Spielman_k100 (level: level4_huge)\nShape: 338402 x 338402\nNon-zeros: 1025404 (avg nnz/row ≈ 3.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/FlowIPM22_Spielman_k100.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "FlowIPM22_Spielman_k100", "num_rows": 338402, "num_cols": 338402, "nnz": 1025404} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Freescale_Freescale1 (level: level4_huge)\nShape: 3428755 x 3428755\nNon-zeros: 18920347 (avg nnz/row ≈ 5.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Freescale_Freescale1.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Freescale_Freescale1", "num_rows": 3428755, "num_cols": 3428755, "nnz": 18920347} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Freescale_circuit5M_dc (level: level4_huge)\nShape: 3523317 x 3523317\nNon-zeros: 19194193 (avg nnz/row ≈ 5.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Freescale_circuit5M_dc.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Freescale_circuit5M_dc", "num_rows": 3523317, "num_cols": 3523317, "nnz": 19194193} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Freescale_memchip (level: level4_huge)\nShape: 2707524 x 2707524\nNon-zeros: 14810202 (avg nnz/row ≈ 5.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Freescale_memchip.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Freescale_memchip", "num_rows": 2707524, "num_cols": 2707524, "nnz": 14810202} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_helm2d03 (level: level4_huge)\nShape: 392257 x 392257\nNon-zeros: 2741935 (avg nnz/row ≈ 7.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/GHS_indef_helm2d03.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "GHS_indef_helm2d03", "num_rows": 392257, "num_cols": 392257, "nnz": 2741935} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: GHS_indef_mario002 (level: level4_huge)\nShape: 389874 x 389874\nNon-zeros: 2101242 (avg nnz/row ≈ 5.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/GHS_indef_mario002.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "GHS_indef_mario002", "num_rows": 389874, "num_cols": 389874, "nnz": 2101242} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hamrle_Hamrle3 (level: level4_huge)\nShape: 1447360 x 1447360\nNon-zeros: 5514242 (avg nnz/row ≈ 3.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Hamrle_Hamrle3.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Hamrle_Hamrle3", "num_rows": 1447360, "num_cols": 1447360, "nnz": 5514242} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Hardesty_Hardesty1 (level: level4_huge)\nShape: 938905 x 938905\nNon-zeros: 12143314 (avg nnz/row ≈ 12.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Hardesty_Hardesty1.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Hardesty_Hardesty1", "num_rows": 938905, "num_cols": 938905, "nnz": 12143314} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: JGD_Margulies_kneser_10_4_1 (level: level4_huge)\nShape: 349651 x 330751\nNon-zeros: 992252 (avg nnz/row ≈ 2.8)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/JGD_Margulies_kneser_10_4_1.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "JGD_Margulies_kneser_10_4_1", "num_rows": 349651, "num_cols": 330751, "nnz": 992252} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Janna_CoupCons3D (level: level4_huge)\nShape: 416800 x 416800\nNon-zeros: 22322336 (avg nnz/row ≈ 53.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Janna_CoupCons3D.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Janna_CoupCons3D", "num_rows": 416800, "num_cols": 416800, "nnz": 22322336} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Kamvar_Stanford_Berkeley (level: level4_huge)\nShape: 683446 x 683446\nNon-zeros: 7583376 (avg nnz/row ≈ 11.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Kamvar_Stanford_Berkeley.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Kamvar_Stanford_Berkeley", "num_rows": 683446, "num_cols": 683446, "nnz": 7583376} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: LAW_dblp-2010 (level: level4_huge)\nShape: 326186 x 326186\nNon-zeros: 1615400 (avg nnz/row ≈ 5.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/LAW_dblp-2010.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "LAW_dblp-2010", "num_rows": 326186, "num_cols": 326186, "nnz": 1615400} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Martin_marine1 (level: level4_huge)\nShape: 400320 x 400320\nNon-zeros: 6226538 (avg nnz/row ≈ 15.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Martin_marine1.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Martin_marine1", "num_rows": 400320, "num_cols": 400320, "nnz": 6226538} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: McRae_ecology2 (level: level4_huge)\nShape: 999999 x 999999\nNon-zeros: 4995991 (avg nnz/row ≈ 5.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/McRae_ecology2.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "McRae_ecology2", "num_rows": 999999, "num_cols": 999999, "nnz": 4995991} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Meszaros_degme (level: level4_huge)\nShape: 185501 x 659415\nNon-zeros: 8127528 (avg nnz/row ≈ 43.8)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Meszaros_degme.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Meszaros_degme", "num_rows": 185501, "num_cols": 659415, "nnz": 8127528} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Pajek_IMDB (level: level4_huge)\nShape: 428440 x 896308\nNon-zeros: 3782463 (avg nnz/row ≈ 8.8)\nMode: rectangular: C = A * A^T\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Pajek_IMDB.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Pajek_IMDB", "num_rows": 428440, "num_cols": 896308, "nnz": 3782463} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_amazon0312 (level: level4_huge)\nShape: 400727 x 400727\nNon-zeros: 3200440 (avg nnz/row ≈ 8.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/SNAP_amazon0312.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "SNAP_amazon0312", "num_rows": 400727, "num_cols": 400727, "nnz": 3200440} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_amazon0505 (level: level4_huge)\nShape: 410236 x 410236\nNon-zeros: 3356824 (avg nnz/row ≈ 8.2)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/SNAP_amazon0505.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "SNAP_amazon0505", "num_rows": 410236, "num_cols": 410236, "nnz": 3356824} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_amazon0601 (level: level4_huge)\nShape: 403394 x 403394\nNon-zeros: 3387388 (avg nnz/row ≈ 8.4)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/SNAP_amazon0601.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "SNAP_amazon0601", "num_rows": 403394, "num_cols": 403394, "nnz": 3387388} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_com-Amazon (level: level4_huge)\nShape: 334863 x 334863\nNon-zeros: 1851744 (avg nnz/row ≈ 5.5)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/SNAP_com-Amazon.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "SNAP_com-Amazon", "num_rows": 334863, "num_cols": 334863, "nnz": 1851744} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_roadNet-CA (level: level4_huge)\nShape: 1971281 x 1971281\nNon-zeros: 5533214 (avg nnz/row ≈ 2.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/SNAP_roadNet-CA.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "SNAP_roadNet-CA", "num_rows": 1971281, "num_cols": 1971281, "nnz": 5533214} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_roadNet-PA (level: level4_huge)\nShape: 1090920 x 1090920\nNon-zeros: 3083796 (avg nnz/row ≈ 2.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/SNAP_roadNet-PA.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "SNAP_roadNet-PA", "num_rows": 1090920, "num_cols": 1090920, "nnz": 3083796} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_roadNet-TX (level: level4_huge)\nShape: 1393383 x 1393383\nNon-zeros: 3843320 (avg nnz/row ≈ 2.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/SNAP_roadNet-TX.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "SNAP_roadNet-TX", "num_rows": 1393383, "num_cols": 1393383, "nnz": 3843320} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_web-BerkStan (level: level4_huge)\nShape: 685230 x 685230\nNon-zeros: 7600595 (avg nnz/row ≈ 11.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/SNAP_web-BerkStan.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "SNAP_web-BerkStan", "num_rows": 685230, "num_cols": 685230, "nnz": 7600595} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: SNAP_web-Google (level: level4_huge)\nShape: 916428 x 916428\nNon-zeros: 5105039 (avg nnz/row ≈ 5.6)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/SNAP_web-Google.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "SNAP_web-Google", "num_rows": 916428, "num_cols": 916428, "nnz": 5105039} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Sandia_ASIC_320ks (level: level4_huge)\nShape: 321671 x 321671\nNon-zeros: 1827807 (avg nnz/row ≈ 5.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Sandia_ASIC_320ks.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Sandia_ASIC_320ks", "num_rows": 321671, "num_cols": 321671, "nnz": 1827807} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_AFE_af_shell1 (level: level4_huge)\nShape: 504855 x 504855\nNon-zeros: 17588875 (avg nnz/row ≈ 34.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Schenk_AFE_af_shell1.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Schenk_AFE_af_shell1", "num_rows": 504855, "num_cols": 504855, "nnz": 17588875} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schenk_AFE_af_shell10 (level: level4_huge)\nShape: 1508065 x 1508065\nNon-zeros: 52672325 (avg nnz/row ≈ 34.9)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Schenk_AFE_af_shell10.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Schenk_AFE_af_shell10", "num_rows": 1508065, "num_cols": 1508065, "nnz": 52672325} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Schmid_thermal2 (level: level4_huge)\nShape: 1228045 x 1228045\nNon-zeros: 8580313 (avg nnz/row ≈ 7.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Schmid_thermal2.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Schmid_thermal2", "num_rows": 1228045, "num_cols": 1228045, "nnz": 8580313} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Sorensen_Linux_call_graph (level: level4_huge)\nShape: 324085 x 324085\nNon-zeros: 1208908 (avg nnz/row ≈ 3.7)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Sorensen_Linux_call_graph.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Sorensen_Linux_call_graph", "num_rows": 324085, "num_cols": 324085, "nnz": 1208908} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: VLSI_test1 (level: level4_huge)\nShape: 392908 x 392908\nNon-zeros: 12968200 (avg nnz/row ≈ 33.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/VLSI_test1.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "VLSI_test1", "num_rows": 392908, "num_cols": 392908, "nnz": 12968200} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Williams_webbase-1M (level: level4_huge)\nShape: 1000005 x 1000005\nNon-zeros: 3105536 (avg nnz/row ≈ 3.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Williams_webbase-1M.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Williams_webbase-1M", "num_rows": 1000005, "num_cols": 1000005, "nnz": 3105536} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Wissgott_parabolic_fem (level: level4_huge)\nShape: 525825 x 525825\nNon-zeros: 3674625 (avg nnz/row ≈ 7.0)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Wissgott_parabolic_fem.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Wissgott_parabolic_fem", "num_rows": 525825, "num_cols": 525825, "nnz": 3674625} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: Zaoui_kkt_power (level: level4_huge)\nShape: 2063494 x 2063494\nNon-zeros: 14612663 (avg nnz/row ≈ 7.1)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/Zaoui_kkt_power.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "Zaoui_kkt_power", "num_rows": 2063494, "num_cols": 2063494, "nnz": 14612663} {"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call cuSPARSE or cuBLAS from your kernel."}, {"role": "user", "content": "Generate a CUDA kernel for SpGEMM on a CSR-format sparse matrix A.\n\nMatrix: vanHeukelum_cage13 (level: level4_huge)\nShape: 445315 x 445315\nNon-zeros: 7479343 (avg nnz/row ≈ 16.8)\nMode: square: C = A * A\n\nDefine exactly these three host-callable functions (names + signatures must match):\n\n void* spgemm_preprocess(const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_compute(void* ctx,\n const int* d_row_ptr, const int* d_col_ind,\n const float* d_values,\n int** d_c_row_ptr, int** d_c_col_ind, float** d_c_values,\n int* c_nnz,\n int num_rows, int num_cols, int nnz);\n\n void spgemm_cleanup(void* ctx);\n\nContract:\n * C is always num_rows x num_rows. Square A: C = A * A. Rectangular A:\n C = A * A^T.\n * Only `spgemm_compute` is timed. It must produce BOTH the structure\n (row_ptr / col_ind) AND the values of C, returned as device CSR arrays\n through the out-parameters, with `*c_nnz` set. The harness frees them.\n * `spgemm_preprocess` may only transform A (or materialize B = A^T for\n the rectangular case, e.g. via cusparseCsr2cscEx2). Computing anything\n about C -- its size, its structure, a symbolic pass -- in preprocess is\n forbidden; it must happen inside compute.\n * All input pointers are device pointers, pre-allocated; do not free them.\n Include . Column indices within each row of C should be\n sorted; duplicates are merged by the checker but cost you correctness\n tolerance.\n\nRespond with one ```cuda fence containing the full kernel.cu."}], "matrix_path": "level_sparse/level4_huge/vanHeukelum_cage13.bin", "op_type": "spgemm", "K": 0, "level": "level4_huge", "matrix_name": "vanHeukelum_cage13", "num_rows": 445315, "num_cols": 445315, "nnz": 7479343}