diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..45c0c3f1a0f236984e1e66268ff0b155a998adf6 --- /dev/null +++ b/README.md @@ -0,0 +1,11 @@ +# Dr.Sparse SpGEMM training pool (607 matrices) + +The complete RL / selector training pool of Dr.Sparse (branch v2): 607 SuiteSparse matrices in the +harness `.bin` layout (int32 rows, cols, nnz; int32 row_ptr; int32 col_ind; float32 values; float32 x), +laid out as level1_small/ (91), level2_medium/ (273), level3_large/ (198), level4_huge/ (45). +Every matrix has a cuSPARSE SpGEMM reference (C = A*A, or A*A^T when rectangular) on an H200; +the 27 that do not are listed in spgemm_excluded.txt and are not included. None of the OTF-81 test +matrices (level_sparse/otf_test_set.csv in the repo) is included. train.jsonl is the per-matrix +prompt file the RL launcher reads; manifest.csv lists rows, cols, nnz and level. + + python level_sparse/extend_pool.py --hf-download KinGeorge/Dr.Sparse-RL-train-607 --out /big/disk/train607 --link-into level_sparse diff --git a/level1_small/Bai_rbsb480.bin b/level1_small/Bai_rbsb480.bin new file mode 100644 index 0000000000000000000000000000000000000000..1376610b4ecc98b2be821925b9051138e9790de6 --- /dev/null +++ b/level1_small/Bai_rbsb480.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e42de9cc17eea4ea532b5afd7c712e4ac966ad4150d37d748a357c75b385f63e +size 140560 diff --git a/level1_small/Boeing_nasa1824.bin b/level1_small/Boeing_nasa1824.bin new file mode 100644 index 0000000000000000000000000000000000000000..9316ed4b085828f2a88c55fe8179325806c1cb61 --- /dev/null +++ b/level1_small/Boeing_nasa1824.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d3b3fc71c92b111e465d0f7f09ba16568f1a8bc8a4a539236faed082cf5cb9fc +size 328272 diff --git a/level1_small/Boeing_nasa2910.bin b/level1_small/Boeing_nasa2910.bin new file mode 100644 index 0000000000000000000000000000000000000000..884457def984fa21772f0f959969c3a9d20e97c8 --- /dev/null +++ b/level1_small/Boeing_nasa2910.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:63734742dccb6f5d8f1cf6b974dd0f845ca6df7a4a3f43f616bc4ce2f91c4eba +size 1417664 diff --git a/level1_small/DRIVCAV_cavity05.bin b/level1_small/DRIVCAV_cavity05.bin new file mode 100644 index 0000000000000000000000000000000000000000..461a8466ef6115cc47fa4f0bce8a927a2795bb95 --- /dev/null +++ b/level1_small/DRIVCAV_cavity05.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:478e68d88c04746a50f1a5a3c9ff0a8e5417a291d043ca33b4f79b5f3ac79b73 +size 271448 diff --git a/level1_small/DRIVCAV_cavity14.bin b/level1_small/DRIVCAV_cavity14.bin new file mode 100644 index 0000000000000000000000000000000000000000..a1961eb75c1d78ab0f692db15c47c89a049c36b0 --- /dev/null +++ b/level1_small/DRIVCAV_cavity14.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2778ea09045eee067b7aea2797b225d4997988c26b2f789ec3b9d69ba35b9c28 +size 631728 diff --git a/level1_small/Dattorro_EternityII_Etilde.bin b/level1_small/Dattorro_EternityII_Etilde.bin new file mode 100644 index 0000000000000000000000000000000000000000..46f52c724a862893d682fc68fb318b1bfa973c87 --- /dev/null +++ b/level1_small/Dattorro_EternityII_Etilde.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a33a73b8b8e857213173b1550bf9d09338ee3f7a009cb778c37cab8a48139902 +size 44332 diff --git a/level1_small/Goodwin_Goodwin_010.bin b/level1_small/Goodwin_Goodwin_010.bin new file mode 100644 index 0000000000000000000000000000000000000000..b80691149c251f176b43118622ed3655186785f4 --- /dev/null +++ b/level1_small/Goodwin_Goodwin_010.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:84f8af0000f7a48898f5996e9e59f08a5b0f85b351b33e1affc8029670acef9f +size 267728 diff --git a/level1_small/Grund_bayer09.bin b/level1_small/Grund_bayer09.bin new file mode 100644 index 0000000000000000000000000000000000000000..883c8c28946cadbc44d86dc6665b52523c175923 --- /dev/null +++ b/level1_small/Grund_bayer09.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8ca9c42d07832d85f547c2aa951d9c430038418e0ed2632bae5e096c68d44396 +size 194408 diff --git a/level1_small/Gset_G29.bin b/level1_small/Gset_G29.bin new file mode 100644 index 0000000000000000000000000000000000000000..1328d130942f28bca675b8ce37e67c30927b5992 --- /dev/null +++ b/level1_small/Gset_G29.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e410eef61504f5408e5e488cae0ebe985b8d1eeaae7671e524f4070192a1eb99 +size 335856 diff --git a/level1_small/Gset_G54.bin b/level1_small/Gset_G54.bin new file mode 100644 index 0000000000000000000000000000000000000000..6d606064996d2bdcaaaa52cb4cf1c4b49b14cbc5 --- /dev/null +++ b/level1_small/Gset_G54.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6abd58c74f282905b82bd5a8a189d7ecec7c9f8afec9b27ab2bc51d66a334743 +size 102672 diff --git a/level1_small/HB_bcsstk13.bin b/level1_small/HB_bcsstk13.bin new file mode 100644 index 0000000000000000000000000000000000000000..9b9e6dee9d0cedeeeddbae638fb0b1180e2dd3a4 --- /dev/null +++ b/level1_small/HB_bcsstk13.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6251cb931fd83fd4f49ca43d695de1c5fb3ba8280a6501492760308d78caa01 +size 687104 diff --git a/level1_small/HB_bcsstm10.bin b/level1_small/HB_bcsstm10.bin new file mode 100644 index 0000000000000000000000000000000000000000..ad20ad4a2122f738da377e3a3d1050b43973220d --- /dev/null +++ b/level1_small/HB_bcsstm10.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e4dcd74867ef025aa00fd6c1b669d67aa1693b63a8bf2b9083d494f885aad5e +size 185440 diff --git a/level1_small/HB_mbeause.bin b/level1_small/HB_mbeause.bin new file mode 100644 index 0000000000000000000000000000000000000000..5ff7dfd502fbb84d76894c3d3e1740dc251bcc06 --- /dev/null +++ b/level1_small/HB_mbeause.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ec5ef9eaac7e703b03d09c92f74deadc68df866d884c38934ec224117e47b2a1 +size 332488 diff --git a/level1_small/HB_psmigr_3.bin b/level1_small/HB_psmigr_3.bin new file mode 100644 index 0000000000000000000000000000000000000000..5ef40b1276016fc19116e6d5f5c8d3dc2f819ee1 --- /dev/null +++ b/level1_small/HB_psmigr_3.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d20c2f177d09d8aff2bd3b25de4ba2c4109385ea3b09ca072f23e59e9e2f46c0 +size 4370432 diff --git a/level1_small/JGD_Forest_TF14.bin b/level1_small/JGD_Forest_TF14.bin new file mode 100644 index 0000000000000000000000000000000000000000..14d82ca82f655f5692d9a10a517c2c2246dad2ca --- /dev/null +++ b/level1_small/JGD_Forest_TF14.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7d4ab2ad0bc4f1e6f8679e57864bcc286fffd7a69a92c1b7138ce0a62603915a +size 262128 diff --git a/level1_small/JGD_Groebner_HFE18_96_in.bin b/level1_small/JGD_Groebner_HFE18_96_in.bin new file mode 100644 index 0000000000000000000000000000000000000000..aa6b3abec9eb273122cddee51e8386bf26b87564 --- /dev/null +++ b/level1_small/JGD_Groebner_HFE18_96_in.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0133d5d384705a5a064ea2ab2ad54581f83b6b6fa227e5f018c3b60a33407217 +size 7492632 diff --git a/level1_small/JGD_Groebner_f855_mat9.bin b/level1_small/JGD_Groebner_f855_mat9.bin new file mode 100644 index 0000000000000000000000000000000000000000..bef6350974f6367c307d0e2cd712d22e3d29f967 --- /dev/null +++ b/level1_small/JGD_Groebner_f855_mat9.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9067ae59069be692f7c769ec116ca74c91c34b5811f5aec46a2382a686229aa1 +size 1389596 diff --git a/level1_small/JGD_Groebner_robot24c1_mat5_J.bin b/level1_small/JGD_Groebner_robot24c1_mat5_J.bin new file mode 100644 index 0000000000000000000000000000000000000000..3c3b6f11ead3c03442bbbba739034566544c91ec --- /dev/null +++ b/level1_small/JGD_Groebner_robot24c1_mat5_J.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7c6acfffc24a0e4d04bc1ad3cd50b29ac0c7c774aba7c9488426fe5840220268 +size 123784 diff --git a/level1_small/JGD_SL6_D_7.bin b/level1_small/JGD_SL6_D_7.bin new file mode 100644 index 0000000000000000000000000000000000000000..d00ec85cd593185d8a62e9a2c6f1766e473b5bcd --- /dev/null +++ b/level1_small/JGD_SL6_D_7.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c4d42195da963b2f2807938c4acd2377cfaa59953244498c00cfb85edc7599c +size 110692 diff --git a/level1_small/MathWorks_TS.bin b/level1_small/MathWorks_TS.bin new file mode 100644 index 0000000000000000000000000000000000000000..3b39739a935354ea9b239c3b555ce090a15c500c --- /dev/null +++ b/level1_small/MathWorks_TS.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d4c4cbe7ff29d9a534afa2568c8feefefb9d81787cb9494dcfd08740fefffe5c +size 379248 diff --git a/level1_small/MathWorks_tomography.bin b/level1_small/MathWorks_tomography.bin new file mode 100644 index 0000000000000000000000000000000000000000..e3ccfbd5102f8dcf0b21f29f58fa6c5060fd2ca0 --- /dev/null +++ b/level1_small/MathWorks_tomography.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c8fe0d8658398225c7d5537c221224de940084e32fc5eb8ac0ba8516b617875 +size 233824 diff --git a/level1_small/Mycielski_mycielskian12.bin b/level1_small/Mycielski_mycielskian12.bin new file mode 100644 index 0000000000000000000000000000000000000000..91882e6f21145c6e271dd4bbc5ef3ed5d4129c10 --- /dev/null +++ b/level1_small/Mycielski_mycielskian12.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:02aab1da31fab36f018612ee70f9297c735047d1679c9a33ef53c54c2c4df934 +size 3282184 diff --git a/level1_small/Mycielski_mycielskian9.bin b/level1_small/Mycielski_mycielskian9.bin new file mode 100644 index 0000000000000000000000000000000000000000..6462910e849489e0708cac184d181319f4e1a8e8 --- /dev/null +++ b/level1_small/Mycielski_mycielskian9.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6086afe7eec36f37b43a3b58d03206f53054f520e0d7f251a8e3741a577a45a6 +size 119416 diff --git a/level1_small/Negre_dendrimer.bin b/level1_small/Negre_dendrimer.bin new file mode 100644 index 0000000000000000000000000000000000000000..2929c643b8c8f540bdcc29bed52a3f838b99eee4 --- /dev/null +++ b/level1_small/Negre_dendrimer.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:03ec50f251db418a9986879f63a530e6579bba4346db6c7f8ce60c82935b08c0 +size 510048 diff --git a/level1_small/Norris_heart2.bin b/level1_small/Norris_heart2.bin new file mode 100644 index 0000000000000000000000000000000000000000..6f071a80ee0ad0777982108fb81e22807f1c1b56 --- /dev/null +++ b/level1_small/Norris_heart2.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c6fefa82a38457c27e59c0c0c24bb3ac36c8217fedb6f52c02583c01262a747 +size 5481104 diff --git a/level1_small/Oberwolfach_spiral.bin b/level1_small/Oberwolfach_spiral.bin new file mode 100644 index 0000000000000000000000000000000000000000..8c82ff6a0d25af44eaa6bd00d389eaaabcd2cb6f --- /dev/null +++ b/level1_small/Oberwolfach_spiral.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:50c8cdebf2179d5c8a5e8c5e6dd791ebee586c785852995f183c6641141d838f +size 157312 diff --git a/level1_small/QCD_conf5_0-4x4-26.bin b/level1_small/QCD_conf5_0-4x4-26.bin new file mode 100644 index 0000000000000000000000000000000000000000..552f5fd915826215aa7aa00db68fdd4401a9b14a --- /dev/null +++ b/level1_small/QCD_conf5_0-4x4-26.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69c50904dab0eea9a93b2daf8fcda1070ea317d4cff63e3d99b607f9ea13eaa1 +size 983056 diff --git a/level1_small/Sandia_adder_dcop_03.bin b/level1_small/Sandia_adder_dcop_03.bin new file mode 100644 index 0000000000000000000000000000000000000000..6b94f732fb736ecd99edb7892e0304b74e759aa4 --- /dev/null +++ b/level1_small/Sandia_adder_dcop_03.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5fc0c74d10f8750e7a9affd1456920235860b9a76c8bc08836d99a524b23dcdc +size 103704 diff --git a/level1_small/Sandia_adder_dcop_31.bin b/level1_small/Sandia_adder_dcop_31.bin new file mode 100644 index 0000000000000000000000000000000000000000..058cf6a6300a4e60f547f407240075154c417cfb --- /dev/null +++ b/level1_small/Sandia_adder_dcop_31.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:059b8d4baa11b64eeadbd82a3dfdce56b858dafe70661139a804371d93a6cc42 +size 104488 diff --git a/level1_small/TSOPF_TSOPF_RS_b300_c3.bin b/level1_small/TSOPF_TSOPF_RS_b300_c3.bin new file mode 100644 index 0000000000000000000000000000000000000000..df8d3f6d9a709d86a6cae7093eb2ea4ddca75d6e --- /dev/null +++ b/level1_small/TSOPF_TSOPF_RS_b300_c3.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d814c53c2b8be264ad817e1d0b6c73060255c9f243d77f9582604e77edde72c +size 337988 diff --git a/level1_small/TSOPF_TSOPF_RS_b39_c19.bin b/level1_small/TSOPF_TSOPF_RS_b39_c19.bin new file mode 100644 index 0000000000000000000000000000000000000000..42849dc4a242c37c59f462eeb97dfa4eb9f033a5 --- /dev/null +++ b/level1_small/TSOPF_TSOPF_RS_b39_c19.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c8869650d2032c9d983d84a8dea4682811a6d2741daceb1b0218b208b7f4374f +size 304908 diff --git a/level1_small/VDOL_spaceShuttleEntry_4.bin b/level1_small/VDOL_spaceShuttleEntry_4.bin new file mode 100644 index 0000000000000000000000000000000000000000..78cf12b5e70264f6be414ce5fb3a9e8637d8ba82 --- /dev/null +++ b/level1_small/VDOL_spaceShuttleEntry_4.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7f9036746c9603f8a61ac161a420680429b0b166a43a779a5d9ef253d5c947e4 +size 336968 diff --git a/level1_small/VDOL_spaceStation_6.bin b/level1_small/VDOL_spaceStation_6.bin new file mode 100644 index 0000000000000000000000000000000000000000..298606dc6d50c0ec550f35d18de6fc5fd8d6158d --- /dev/null +++ b/level1_small/VDOL_spaceStation_6.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c21e35bbeefafd88ad313d9976fcc0dca8d33ab873495d5d75b3281196d976e +size 149664 diff --git a/level1_small/Zitney_rdist3a.bin b/level1_small/Zitney_rdist3a.bin new file mode 100644 index 0000000000000000000000000000000000000000..ca864b8b685aac12add40c03d4ba72244f2c3214 --- /dev/null +++ b/level1_small/Zitney_rdist3a.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b5c49920f248407a37c3c67a770ba27c229ab3f8a6af4f1f174c37ff8701de9a +size 514368 diff --git a/level2_medium/HB_gemat12.bin b/level2_medium/HB_gemat12.bin new file mode 100644 index 0000000000000000000000000000000000000000..81476adbdc4dab76f5284b69837b42f6bbd4b3b7 --- /dev/null +++ b/level2_medium/HB_gemat12.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41c0ccee935e64e2ca09ce58efd04aabadbf47eba5944f11a81f1b575f9b72ca +size 304336 diff --git a/level3_large/AG-Monien_ccc.bin b/level3_large/AG-Monien_ccc.bin new file mode 100644 index 0000000000000000000000000000000000000000..8bd367bc2c1faec9806a757e612d54181aa106f1 --- /dev/null +++ b/level3_large/AG-Monien_ccc.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:05cc76974d2f0d4058ea93b6c2053f8852d4c63a10e1b59b4475f76b3a1031ea +size 1572880 diff --git a/level3_large/Andrianov_net125.bin b/level3_large/Andrianov_net125.bin new file mode 100644 index 0000000000000000000000000000000000000000..fd93f350e8da9eefaf90d1ceee9e8c4f92e92819 --- /dev/null +++ b/level3_large/Andrianov_net125.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fba291e0b20443e4d21aa5ae8a0e1338c76355f1bf07b063bec0a3e7b739e382 +size 20911376 diff --git a/level3_large/Botonakis_FEM_3D_thermal2.bin b/level3_large/Botonakis_FEM_3D_thermal2.bin new file mode 100644 index 0000000000000000000000000000000000000000..e9a0bb8b7bf6030fb910554f84b5d47be23095a1 --- /dev/null +++ b/level3_large/Botonakis_FEM_3D_thermal2.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a411e3ba147f41043f76b2db1db6ce524bbaac944814b0339ce0d689df4247c5 +size 29097616 diff --git a/level3_large/Botonakis_thermomech_dK.bin b/level3_large/Botonakis_thermomech_dK.bin new file mode 100644 index 0000000000000000000000000000000000000000..b3c9e1cda778d4ee5b9133916602216edf403795 --- /dev/null +++ b/level3_large/Botonakis_thermomech_dK.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:01d67617273485ecd27488de9a93a162570a36135cf0a4d6c4ee3b912cb00c51 +size 24404368 diff --git a/level3_large/Castrillon_denormal.bin b/level3_large/Castrillon_denormal.bin new file mode 100644 index 0000000000000000000000000000000000000000..37b07891ebfb6ab86a67c50fff092a2e2662ccca --- /dev/null +++ b/level3_large/Castrillon_denormal.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:179ecc95bcc510313d6703394d8f2120ada2fd7cc5c5f00764df14a0924decc1 +size 9965008 diff --git a/level3_large/DIMACS10_al2010.bin b/level3_large/DIMACS10_al2010.bin new file mode 100644 index 0000000000000000000000000000000000000000..99191c8e4b9bcd0625264b566aab0f7f11545309 --- /dev/null +++ b/level3_large/DIMACS10_al2010.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bf2f9d4bb0457e237bcfeb47e3d5cfbd4dc408059e4a4167d715015a20f9d4fd +size 11862000 diff --git a/level3_large/DIMACS10_coAuthorsCiteseer.bin b/level3_large/DIMACS10_coAuthorsCiteseer.bin new file mode 100644 index 0000000000000000000000000000000000000000..9c517a4773565c91603572f2b010973eb9667d4c --- /dev/null +++ b/level3_large/DIMACS10_coAuthorsCiteseer.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f8d6d43aceabaaac4c52cd0235f56640650b7ee08c4e9b304ce782b22c5dfb5e +size 14844720 diff --git a/level3_large/DIMACS10_rgg_n_2_15_s0.bin b/level3_large/DIMACS10_rgg_n_2_15_s0.bin new file mode 100644 index 0000000000000000000000000000000000000000..0dca43b4513a6b7441302cfdf01c39d38f25a668 --- /dev/null +++ b/level3_large/DIMACS10_rgg_n_2_15_s0.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:18621282232b6626e23e9b98bd81fb0156f11fb87254086330739ed8080a876a +size 2826000 diff --git a/level3_large/DIMACS10_rgg_n_2_18_s0.bin b/level3_large/DIMACS10_rgg_n_2_18_s0.bin new file mode 100644 index 0000000000000000000000000000000000000000..e602f4caea6a75f86324280e571aa5bdb4538226 --- /dev/null +++ b/level3_large/DIMACS10_rgg_n_2_18_s0.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5d4b23eef0d6a47f2a488fcb84daf7c2f944e20553da648066b7ec4fa9a00e +size 26853696 diff --git a/level3_large/DIMACS10_vsp_vibrobox_scagr7-2c_rlfddd.bin b/level3_large/DIMACS10_vsp_vibrobox_scagr7-2c_rlfddd.bin new file mode 100644 index 0000000000000000000000000000000000000000..e1311f6708e96f2b51cf91fb6aa978f33d99a0b3 --- /dev/null +++ b/level3_large/DIMACS10_vsp_vibrobox_scagr7-2c_rlfddd.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b79bf90619f0b006e90bc1d2a0e68f3876e409ec603f8d7d9a7b970cc512559f +size 7588016 diff --git a/level3_large/GHS_indef_c-58.bin b/level3_large/GHS_indef_c-58.bin new file mode 100644 index 0000000000000000000000000000000000000000..81dd33d6f5cab808d9396f5b3499e2191870b794 --- /dev/null +++ b/level3_large/GHS_indef_c-58.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c0b48e6f1716cb908ee86ec9fa15e24817c5be38d212b5076dc181571c6978d3 +size 4721232 diff --git a/level3_large/GHS_indef_c-63.bin b/level3_large/GHS_indef_c-63.bin new file mode 100644 index 0000000000000000000000000000000000000000..599c41612513434056b0fb6cd7f73d915513025c --- /dev/null +++ b/level3_large/GHS_indef_c-63.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bd3c50f82f412b144e258c5d7fe6ff00d969a5709d8f1cb2e881a9e45520a002 +size 3831520 diff --git a/level3_large/GHS_indef_c-72.bin b/level3_large/GHS_indef_c-72.bin new file mode 100644 index 0000000000000000000000000000000000000000..b7d7cca90e07a87320c0124f08ba92ab56f3e549 --- /dev/null +++ b/level3_large/GHS_indef_c-72.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:acf8a9e0330aac2ed00a4dfeddc43c627770a7cb7542332c0b6249e954d06d4a +size 6332992 diff --git a/level3_large/GHS_psdef_wathen120.bin b/level3_large/GHS_psdef_wathen120.bin new file mode 100644 index 0000000000000000000000000000000000000000..09e700d164c12ac597bdb8fdd5b8893093ad87fc --- /dev/null +++ b/level3_large/GHS_psdef_wathen120.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:caec8d40844ba61b0a710fef05c5ba47f86505d659f42485b9db359a68e49150 +size 4817632 diff --git a/level3_large/Grund_bayer01.bin b/level3_large/Grund_bayer01.bin new file mode 100644 index 0000000000000000000000000000000000000000..bf823b73f421891787dadd11257554145db46f78 --- /dev/null +++ b/level3_large/Grund_bayer01.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:11cfe39ec271fae1a14280892623f1abba682688413c81f96ad148267de9b5d6 +size 2684088 diff --git a/level3_large/Guettel_TEM181302.bin b/level3_large/Guettel_TEM181302.bin new file mode 100644 index 0000000000000000000000000000000000000000..2402e6df3140d14f8416d720cfebefa3e516e8bd --- /dev/null +++ b/level3_large/Guettel_TEM181302.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2fd929d706eb9af34d6b678775219a3db81653cfd9cb3fab14824f2313841c9c +size 64162512 diff --git a/level3_large/Hollinger_mark3jac100.bin b/level3_large/Hollinger_mark3jac100.bin new file mode 100644 index 0000000000000000000000000000000000000000..47ccbaeb6e150106fdb901d8bba35ff7d48489df --- /dev/null +++ b/level3_large/Hollinger_mark3jac100.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d613f20ac1fa13ea5bbe93f468b6f237caf7650ef1264e2370f0d64b05ccacaf +size 2647888 diff --git a/level3_large/Hollinger_mark3jac120sc.bin b/level3_large/Hollinger_mark3jac120sc.bin new file mode 100644 index 0000000000000000000000000000000000000000..717333332ea390af044691eea426f1390f085532 --- /dev/null +++ b/level3_large/Hollinger_mark3jac120sc.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e57dab50759b3b84f9441b663aba27b52b537319797ccccd49f277fe614a33be +size 3179248 diff --git a/level3_large/Mallya_lhr34c.bin b/level3_large/Mallya_lhr34c.bin new file mode 100644 index 0000000000000000000000000000000000000000..7e4936e74aea68aa919a4b2491c727a97b5b1675 --- /dev/null +++ b/level3_large/Mallya_lhr34c.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:38c3a4be170ef7029adf51edf921d5d8b8469f4e447425612867e583033f222a +size 6393344 diff --git a/level3_large/Meszaros_fxm3_16.bin b/level3_large/Meszaros_fxm3_16.bin new file mode 100644 index 0000000000000000000000000000000000000000..998c83c030390f163b2bcf0b03e7c40c00553965 --- /dev/null +++ b/level3_large/Meszaros_fxm3_16.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7307d791240c796e8d785987c5ee40adcbdd6d69274402089dcf9fe97e01f332 +size 3645692 diff --git a/level3_large/Meszaros_karted.bin b/level3_large/Meszaros_karted.bin new file mode 100644 index 0000000000000000000000000000000000000000..5e36a743d37dfdf391faca6c458047a14af82373 --- /dev/null +++ b/level3_large/Meszaros_karted.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fa8cbc6d846f58474f95e2fc41beb6d28e740a988a78d6a6e982b1b4633ec144 +size 14881276 diff --git a/level3_large/Mittelmann_watson_1.bin b/level3_large/Mittelmann_watson_1.bin new file mode 100644 index 0000000000000000000000000000000000000000..4240395428a0b1632443542ca36b04cd3056e1c1 --- /dev/null +++ b/level3_large/Mittelmann_watson_1.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9b3bc0899e6f19c860659bd95bbbc6421806e8bb0ae8fc386a1d993cafecd17d +size 10793348 diff --git a/level3_large/Norris_torso3.bin b/level3_large/Norris_torso3.bin new file mode 100644 index 0000000000000000000000000000000000000000..df971ad70996de29ed8ea9f5709f8f56fa9326b9 --- /dev/null +++ b/level3_large/Norris_torso3.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:53a9d679e5c7a4a2fdba06f57ebec3637754a28b848d7dc55192d6969f701d59 +size 37505600 diff --git a/level3_large/Oberwolfach_gas_sensor.bin b/level3_large/Oberwolfach_gas_sensor.bin new file mode 100644 index 0000000000000000000000000000000000000000..dfcebfc0a959f753a475a6d22381cdae9d890ee0 --- /dev/null +++ b/level3_large/Oberwolfach_gas_sensor.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7672c2448668cbf37fb5a62d4559cbdc046208f4631a17a00785981271bb87c8 +size 14162272 diff --git a/level3_large/PARSEC_Ga10As10H30.bin b/level3_large/PARSEC_Ga10As10H30.bin new file mode 100644 index 0000000000000000000000000000000000000000..5ef4526792462d462ac7950529676005e34713f8 --- /dev/null +++ b/level3_large/PARSEC_Ga10As10H30.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:532ad3f8895b7fc3c44d6058d1ebde3355e5ad85fe9c03273c4ee4e65d8d78b5 +size 49829728 diff --git a/level3_large/PARSEC_Ga19As19H42.bin b/level3_large/PARSEC_Ga19As19H42.bin new file mode 100644 index 0000000000000000000000000000000000000000..66dcc04b9b381566abba3e184503109964820afe --- /dev/null +++ b/level3_large/PARSEC_Ga19As19H42.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d9f035dc670abe8a3bb9a298fe31416ca033bd51b6bb451f93bf103c775befaa +size 72143712 diff --git a/level3_large/Rothberg_gearbox.bin b/level3_large/Rothberg_gearbox.bin new file mode 100644 index 0000000000000000000000000000000000000000..aebafd001a09df5cb51fd80866b65fd0c1aeab48 --- /dev/null +++ b/level3_large/Rothberg_gearbox.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:684a05d42aca07372d5935d83d787327a2a17940e714a182fae6e5b8c44ff15a +size 73873216 diff --git a/level3_large/SNAP_soc-sign-Slashdot090216.bin b/level3_large/SNAP_soc-sign-Slashdot090216.bin new file mode 100644 index 0000000000000000000000000000000000000000..ea3eded47bf4de142502851feb0beec5aff37c87 --- /dev/null +++ b/level3_large/SNAP_soc-sign-Slashdot090216.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c57522278b8149e9ed70fbf4657fbd68943715cdc95730f2bacd4d9de02ecf6 +size 5020352 diff --git a/level3_large/Schenk_IBMNA_c-60.bin b/level3_large/Schenk_IBMNA_c-60.bin new file mode 100644 index 0000000000000000000000000000000000000000..f65b17d23228e7011d50c79471f4e5122f1f6173 --- /dev/null +++ b/level3_large/Schenk_IBMNA_c-60.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd643356a335d3ea2625bf166f22b3fce44e2cb9fa3b7d0e92365f21d587932e +size 2737760 diff --git a/level3_large/Schenk_IBMNA_c-67b.bin b/level3_large/Schenk_IBMNA_c-67b.bin new file mode 100644 index 0000000000000000000000000000000000000000..6c8d5044a4f0deaa96b5bb64d1b2b9fa338e71ad --- /dev/null +++ b/level3_large/Schenk_IBMNA_c-67b.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:065de0b21622fe0f9dea06b57578fc4d624028ab9635f8daf101fc02b80be035 +size 4719296 diff --git a/level3_large/Schenk_ISEI_para-9.bin b/level3_large/Schenk_ISEI_para-9.bin new file mode 100644 index 0000000000000000000000000000000000000000..d74edd74a981de3fa6cb5813d8fc363dbada7cbe --- /dev/null +++ b/level3_large/Schenk_ISEI_para-9.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:521c0d735149eb0cfb80554f9d6ad111ab844d3c1ffaed62a69285aec698c423 +size 44578272 diff --git a/level3_large/Toledo_deltaX.bin b/level3_large/Toledo_deltaX.bin new file mode 100644 index 0000000000000000000000000000000000000000..f980f02f7729100914be9e81de7198c625b1982d --- /dev/null +++ b/level3_large/Toledo_deltaX.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a71035e3aed68f3805666388a5a111ff7e78078341d0392cb06197d7986420ad +size 2341652 diff --git a/level3_large/VLSI_ss1.bin b/level3_large/VLSI_ss1.bin new file mode 100644 index 0000000000000000000000000000000000000000..5fc87a259d0433da59c25c40614d0670c4d40ea2 --- /dev/null +++ b/level3_large/VLSI_ss1.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:48eb048d2ebf80f74ada626a67976dae4e8417d2f2a150e37c7864408001f983 +size 8402984 diff --git a/level3_large/Yoshiyasu_image_interp.bin b/level3_large/Yoshiyasu_image_interp.bin new file mode 100644 index 0000000000000000000000000000000000000000..676fd49ee34563ca8171f6875a5a8fa9c230f3d3 --- /dev/null +++ b/level3_large/Yoshiyasu_image_interp.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cf05d670763b4e26677183915eab6da704bf217eaaff3af742e7a611e88492c7 +size 7133480 diff --git a/level4_huge/DIMACS10_delaunay_n24.bin b/level4_huge/DIMACS10_delaunay_n24.bin new file mode 100644 index 0000000000000000000000000000000000000000..b5f0e0eef24cd95d0dd82fb57ea296a5901931e8 --- /dev/null +++ b/level4_huge/DIMACS10_delaunay_n24.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0027baf7b42e5ebd94c35aabc73a8660fbe66461cf76ad51e987a4701d446a34 +size 939523360 diff --git a/manifest.csv b/manifest.csv new file mode 100644 index 0000000000000000000000000000000000000000..df1971a9f24743bb070f2a35ac820b4b50d40514 --- /dev/null +++ b/manifest.csv @@ -0,0 +1,608 @@ +matrix,level,rows,cols,nnz,path +Arenas_email,level1_small,1133,1133,10902,level1_small/Arenas_email.bin +Bai_rbsb480,level1_small,480,480,17088,level1_small/Bai_rbsb480.bin +Boeing_msc00726,level1_small,726,726,34518,level1_small/Boeing_msc00726.bin +Boeing_nasa1824,level1_small,1824,1824,39208,level1_small/Boeing_nasa1824.bin +Boeing_nasa2910,level1_small,2910,2910,174296,level1_small/Boeing_nasa2910.bin +CPM_cz1268,level1_small,1268,1268,12786,level1_small/CPM_cz1268.bin +DRIVCAV_cavity05,level1_small,1182,1182,32747,level1_small/DRIVCAV_cavity05.bin +DRIVCAV_cavity10,level1_small,2597,2597,76367,level1_small/DRIVCAV_cavity10.bin +DRIVCAV_cavity14,level1_small,2597,2597,76367,level1_small/DRIVCAV_cavity14.bin +DRIVCAV_cavity15,level1_small,2597,2597,76367,level1_small/DRIVCAV_cavity15.bin +Dattorro_EternityII_A,level1_small,7362,1,358,level1_small/Dattorro_EternityII_A.bin +Dattorro_EternityII_Etilde,level1_small,10054,1,512,level1_small/Dattorro_EternityII_Etilde.bin +FIDAP_ex20,level1_small,2203,2203,69981,level1_small/FIDAP_ex20.bin +FIDAP_ex23,level1_small,1409,1409,43703,level1_small/FIDAP_ex23.bin +FIDAP_ex24,level1_small,2283,2283,48737,level1_small/FIDAP_ex24.bin +FIDAP_ex36,level1_small,3079,3079,53843,level1_small/FIDAP_ex36.bin +FIDAP_ex4,level1_small,1601,1601,32299,level1_small/FIDAP_ex4.bin +FIDAP_ex7,level1_small,1633,1633,54543,level1_small/FIDAP_ex7.bin +Goodwin_Goodwin_010,level1_small,1182,1182,32282,level1_small/Goodwin_Goodwin_010.bin +Grund_bayer08,level1_small,3008,3008,27576,level1_small/Grund_bayer08.bin +Grund_bayer09,level1_small,3083,3083,21216,level1_small/Grund_bayer09.bin +Grund_meg1,level1_small,2904,2904,58142,level1_small/Grund_meg1.bin +Gset_G29,level1_small,2000,2000,39980,level1_small/Gset_G29.bin +Gset_G39,level1_small,2000,2000,23556,level1_small/Gset_G39.bin +Gset_G5,level1_small,800,800,38352,level1_small/Gset_G5.bin +Gset_G54,level1_small,1000,1000,11832,level1_small/Gset_G54.bin +HB_bcsstk12,level1_small,1473,1473,34241,level1_small/HB_bcsstk12.bin +HB_bcsstk13,level1_small,2003,2003,83883,level1_small/HB_bcsstk13.bin +HB_bcsstm10,level1_small,1086,1086,22092,level1_small/HB_bcsstm10.bin +HB_bcsstm13,level1_small,2003,2003,21943,level1_small/HB_bcsstm13.bin +HB_cegb2802,level1_small,2802,2802,277362,level1_small/HB_cegb2802.bin +HB_lock2232,level1_small,2232,2232,80352,level1_small/HB_lock2232.bin +HB_lshp1561,level1_small,1561,1561,10681,level1_small/HB_lshp1561.bin +HB_mbeause,level1_small,496,496,41063,level1_small/HB_mbeause.bin +HB_orani678,level1_small,2529,2529,90158,level1_small/HB_orani678.bin +HB_psmigr_1,level1_small,3140,3140,543162,level1_small/HB_psmigr_1.bin +HB_psmigr_2,level1_small,3140,3140,540022,level1_small/HB_psmigr_2.bin +HB_psmigr_3,level1_small,3140,3140,543162,level1_small/HB_psmigr_3.bin +JGD_CAG_CAG_mat1916,level1_small,1916,1916,195985,level1_small/JGD_CAG_CAG_mat1916.bin +JGD_CAG_CAG_mat364,level1_small,364,364,13585,level1_small/JGD_CAG_CAG_mat364.bin +JGD_Forest_TF14,level1_small,2644,3160,29862,level1_small/JGD_Forest_TF14.bin +JGD_Groebner_HFE18_96_in,level1_small,2372,4096,933343,level1_small/JGD_Groebner_HFE18_96_in.bin +JGD_Groebner_f855_mat9,level1_small,2456,2511,171214,level1_small/JGD_Groebner_f855_mat9.bin +JGD_Groebner_f855_mat9_I,level1_small,2456,2511,171214,level1_small/JGD_Groebner_f855_mat9_I.bin +JGD_Groebner_robot24c1_mat5_J,level1_small,302,404,15118,level1_small/JGD_Groebner_robot24c1_mat5_J.bin +JGD_Kocay_Trec13,level1_small,1301,6561,654517,level1_small/JGD_Kocay_Trec13.bin +JGD_SL6_D_7,level1_small,1270,971,12714,level1_small/JGD_SL6_D_7.bin +JGD_SPG_EX3,level1_small,2600,2600,71760,level1_small/JGD_SPG_EX3.bin +JGD_Taha_abtaha1,level1_small,14596,209,51307,level1_small/JGD_Taha_abtaha1.bin +JGD_Trefethen_Trefethen_2000,level1_small,2000,2000,41906,level1_small/JGD_Trefethen_Trefethen_2000.bin +JGD_Trefethen_Trefethen_700,level1_small,700,700,12654,level1_small/JGD_Trefethen_Trefethen_700.bin +LeGresley_LeGresley_2508,level1_small,2508,2508,16727,level1_small/LeGresley_LeGresley_2508.bin +ML_Graph_YaleB_10NN,level1_small,2414,2414,34808,level1_small/ML_Graph_YaleB_10NN.bin +ML_Graph_dataset20mfeatpixel_10NN,level1_small,2000,2000,27932,level1_small/ML_Graph_dataset20mfeatpixel_10NN.bin +ML_Graph_yeast_30NN,level1_small,1484,1484,62350,level1_small/ML_Graph_yeast_30NN.bin +Mallya_lhr02,level1_small,2954,2954,37206,level1_small/Mallya_lhr02.bin +MathWorks_TS,level1_small,2142,2142,45262,level1_small/MathWorks_TS.bin +MathWorks_tomography,level1_small,500,500,28726,level1_small/MathWorks_tomography.bin +Meszaros_aa5,level1_small,801,8308,65953,level1_small/Meszaros_aa5.bin +Moqri_MISKnowledgeMap,level1_small,2427,2427,57022,level1_small/Moqri_MISKnowledgeMap.bin +Morandini_rotor2,level1_small,791,791,10685,level1_small/Morandini_rotor2.bin +Mycielski_mycielskian11,level1_small,1535,1535,134710,level1_small/Mycielski_mycielskian11.bin +Mycielski_mycielskian12,level1_small,3071,3071,407200,level1_small/Mycielski_mycielskian12.bin +Mycielski_mycielskian9,level1_small,383,383,14542,level1_small/Mycielski_mycielskian9.bin +Negre_dendrimer,level1_small,730,730,63024,level1_small/Negre_dendrimer.bin +Newman_polblogs,level1_small,1490,1490,19025,level1_small/Newman_polblogs.bin +Norris_heart2,level1_small,2339,2339,682797,level1_small/Norris_heart2.bin +Norris_heart3,level1_small,2339,2339,682797,level1_small/Norris_heart3.bin +Oberwolfach_piston,level1_small,2025,2025,100015,level1_small/Oberwolfach_piston.bin +Oberwolfach_spiral,level1_small,1434,1434,18228,level1_small/Oberwolfach_spiral.bin +QCD_conf5_0-4x4-26,level1_small,3072,3072,119808,level1_small/QCD_conf5_0-4x4-26.bin +SNAP_CollegeMsg,level1_small,1899,1899,20296,level1_small/SNAP_CollegeMsg.bin +SNAP_email-Eu-core-temporal,level1_small,1005,1005,24929,level1_small/SNAP_email-Eu-core-temporal.bin +SNAP_email-Eu-core,level1_small,1005,1005,25571,level1_small/SNAP_email-Eu-core.bin +Sandia_adder_dcop_03,level1_small,1813,1813,11148,level1_small/Sandia_adder_dcop_03.bin +Sandia_adder_dcop_18,level1_small,1813,1813,11246,level1_small/Sandia_adder_dcop_18.bin +Sandia_adder_dcop_31,level1_small,1813,1813,11246,level1_small/Sandia_adder_dcop_31.bin +Sandia_adder_dcop_37,level1_small,1813,1813,11246,level1_small/Sandia_adder_dcop_37.bin +Sandia_adder_dcop_64,level1_small,1813,1813,11246,level1_small/Sandia_adder_dcop_64.bin +Sandia_adder_trans_01,level1_small,1814,1814,14579,level1_small/Sandia_adder_trans_01.bin +TOKAMAK_utm1700b,level1_small,1700,1700,21509,level1_small/TOKAMAK_utm1700b.bin +TOKAMAK_utm3060,level1_small,3060,3060,42211,level1_small/TOKAMAK_utm3060.bin +TSOPF_TSOPF_RS_b300_c3,level1_small,42138,137,21109,level1_small/TSOPF_TSOPF_RS_b300_c3.bin +TSOPF_TSOPF_RS_b39_c19,level1_small,38098,19,19053,level1_small/TSOPF_TSOPF_RS_b39_c19.bin +TSOPF_TSOPF_RS_b39_c7,level1_small,14098,19,7053,level1_small/TSOPF_TSOPF_RS_b39_c7.bin +VDOL_hangGlider_2,level1_small,1647,1647,14754,level1_small/VDOL_hangGlider_2.bin +VDOL_spaceShuttleEntry_4,level1_small,2450,2450,39669,level1_small/VDOL_spaceShuttleEntry_4.bin +VDOL_spaceStation_6,level1_small,1111,1111,17595,level1_small/VDOL_spaceStation_6.bin +Wang_wang1,level1_small,2903,2903,19093,level1_small/Wang_wang1.bin +Zitney_extr1,level1_small,2837,2837,11407,level1_small/Zitney_extr1.bin +Zitney_rdist3a,level1_small,2398,2398,61896,level1_small/Zitney_rdist3a.bin +ACUSIM_Pres_Poisson,level2_medium,14822,14822,715804,level2_medium/ACUSIM_Pres_Poisson.bin +AG-Monien_ukerbe1,level2_medium,5981,5981,15704,level2_medium/AG-Monien_ukerbe1.bin +Andrianov_ex3sta1,level2_medium,16782,16782,678998,level2_medium/Andrianov_ex3sta1.bin +Andrianov_fxm4_6,level2_medium,18892,18892,497844,level2_medium/Andrianov_fxm4_6.bin +Andrianov_net100,level2_medium,29920,29920,2033200,level2_medium/Andrianov_net100.bin +Andrianov_net25,level2_medium,9520,9520,401200,level2_medium/Andrianov_net25.bin +Andrianov_net50,level2_medium,16320,16320,945200,level2_medium/Andrianov_net50.bin +Andrianov_net75,level2_medium,23120,23120,1489200,level2_medium/Andrianov_net75.bin +Andrianov_pf2177,level2_medium,9728,9728,725144,level2_medium/Andrianov_pf2177.bin +Arenas_PGPgiantcompo,level2_medium,10680,10680,48632,level2_medium/Arenas_PGPgiantcompo.bin +Bai_af23560,level2_medium,23560,23560,484256,level2_medium/Bai_af23560.bin +Bai_dw4096,level2_medium,8192,8192,41746,level2_medium/Bai_dw4096.bin +Bai_mhd3200a,level2_medium,3200,3200,68026,level2_medium/Bai_mhd3200a.bin +Bai_mhd4800a,level2_medium,4800,4800,102252,level2_medium/Bai_mhd4800a.bin +Bai_rw5151,level2_medium,5151,5151,20199,level2_medium/Bai_rw5151.bin +Bates_Chem97Zt,level2_medium,2541,31022,62044,level2_medium/Bates_Chem97Zt.bin +Bindel_ted_A,level2_medium,10605,10605,424587,level2_medium/Bindel_ted_A.bin +Bindel_ted_A_unscaled,level2_medium,10605,10605,424587,level2_medium/Bindel_ted_A_unscaled.bin +Bindel_ted_B,level2_medium,10605,10605,144579,level2_medium/Bindel_ted_B.bin +Bindel_ted_B_unscaled,level2_medium,10605,10605,144579,level2_medium/Bindel_ted_B_unscaled.bin +Bodendiek_CurlCurl_0,level2_medium,11083,11083,113343,level2_medium/Bodendiek_CurlCurl_0.bin +Boeing_bcsstk38,level2_medium,8032,8032,355460,level2_medium/Boeing_bcsstk38.bin +Boeing_crystk01,level2_medium,4875,4875,315891,level2_medium/Boeing_crystk01.bin +Boeing_crystk02,level2_medium,13965,13965,968583,level2_medium/Boeing_crystk02.bin +Boeing_crystk03,level2_medium,24696,24696,1751178,level2_medium/Boeing_crystk03.bin +Boeing_crystm01,level2_medium,4875,4875,105339,level2_medium/Boeing_crystm01.bin +Boeing_crystm02,level2_medium,13965,13965,322905,level2_medium/Boeing_crystm02.bin +Boeing_nasa4704,level2_medium,4704,4704,104756,level2_medium/Boeing_nasa4704.bin +Boeing_pcrystk02,level2_medium,13965,13965,968583,level2_medium/Boeing_pcrystk02.bin +Bomhof_circuit_2,level2_medium,4510,4510,21199,level2_medium/Bomhof_circuit_2.bin +Bomhof_circuit_3,level2_medium,12127,12127,48137,level2_medium/Bomhof_circuit_3.bin +Botonakis_FEM_3D_thermal1,level2_medium,17880,17880,430740,level2_medium/Botonakis_FEM_3D_thermal1.bin +Brethour_coater2,level2_medium,9540,9540,207308,level2_medium/Brethour_coater2.bin +CPM_cz5108,level2_medium,5108,5108,51412,level2_medium/CPM_cz5108.bin +Cannizzo_sts4098,level2_medium,4098,4098,72356,level2_medium/Cannizzo_sts4098.bin +Chen_pkustk02,level2_medium,10800,10800,810000,level2_medium/Chen_pkustk02.bin +Cote_mplate,level2_medium,5962,5962,142190,level2_medium/Cote_mplate.bin +Cote_vibrobox,level2_medium,12328,12328,342828,level2_medium/Cote_vibrobox.bin +Cunningham_k3plates,level2_medium,11107,11107,378927,level2_medium/Cunningham_k3plates.bin +Cylshell_s3rmq4m1,level2_medium,5489,5489,281111,level2_medium/Cylshell_s3rmq4m1.bin +DIMACS10_vsp_c-30_data_data,level2_medium,11023,11023,124368,level2_medium/DIMACS10_vsp_c-30_data_data.bin +DIMACS10_vsp_data_and_seymourl,level2_medium,9167,9167,111732,level2_medium/DIMACS10_vsp_data_and_seymourl.bin +DIMACS10_wing_nodal,level2_medium,10937,10937,150976,level2_medium/DIMACS10_wing_nodal.bin +DNVS_trdheim,level2_medium,22098,22098,1935324,level2_medium/DNVS_trdheim.bin +DNVS_tsyl201,level2_medium,20685,20685,2454957,level2_medium/DNVS_tsyl201.bin +DRIVCAV_cavity17,level2_medium,4562,4562,138187,level2_medium/DRIVCAV_cavity17.bin +DRIVCAV_cavity20,level2_medium,4562,4562,138187,level2_medium/DRIVCAV_cavity20.bin +DRIVCAV_cavity21,level2_medium,4562,4562,138187,level2_medium/DRIVCAV_cavity21.bin +DRIVCAV_cavity22,level2_medium,4562,4562,138187,level2_medium/DRIVCAV_cavity22.bin +Davis_FX_March2010,level2_medium,1319,9498,301899,level2_medium/Davis_FX_March2010.bin +FEMLAB_poisson3Da,level2_medium,13514,13514,352762,level2_medium/FEMLAB_poisson3Da.bin +FIDAP_ex37,level2_medium,3565,3565,67591,level2_medium/FIDAP_ex37.bin +FIDAP_ex40,level2_medium,7740,7740,458012,level2_medium/FIDAP_ex40.bin +FIDAP_ex9,level2_medium,3363,3363,99471,level2_medium/FIDAP_ex9.bin +Fluorem_GT01R,level2_medium,7980,7980,430909,level2_medium/Fluorem_GT01R.bin +GHS_indef_bloweya,level2_medium,30004,30004,150009,level2_medium/GHS_indef_bloweya.bin +GHS_indef_bloweybl,level2_medium,30003,30003,120000,level2_medium/GHS_indef_bloweybl.bin +GHS_indef_bratu3d,level2_medium,27792,27792,173796,level2_medium/GHS_indef_bratu3d.bin +GHS_indef_linverse,level2_medium,11999,11999,95977,level2_medium/GHS_indef_linverse.bin +GHS_indef_tuma1,level2_medium,22967,22967,87760,level2_medium/GHS_indef_tuma1.bin +GHS_indef_tuma2,level2_medium,12992,12992,49365,level2_medium/GHS_indef_tuma2.bin +GHS_psdef_ramage02,level2_medium,16830,16830,2866352,level2_medium/GHS_psdef_ramage02.bin +GHS_psdef_wathen100,level2_medium,30401,30401,471601,level2_medium/GHS_psdef_wathen100.bin +Gaertner_big,level2_medium,13209,13209,91465,level2_medium/Gaertner_big.bin +Gleich_wb-cs-stanford,level2_medium,9914,9914,36854,level2_medium/Gleich_wb-cs-stanford.bin +Goodwin_Goodwin_030,level2_medium,10142,10142,312814,level2_medium/Goodwin_Goodwin_030.bin +Goodwin_Goodwin_040,level2_medium,17922,17922,561677,level2_medium/Goodwin_Goodwin_040.bin +Goodwin_rim,level2_medium,22560,22560,1014951,level2_medium/Goodwin_rim.bin +Graham_graham1,level2_medium,9035,9035,335504,level2_medium/Graham_graham1.bin +Grueninger_windtunnel_evap2d,level2_medium,8256,8256,233468,level2_medium/Grueninger_windtunnel_evap2d.bin +Grund_poli3,level2_medium,16955,16955,37849,level2_medium/Grund_poli3.bin +Gset_G56,level2_medium,5000,5000,24996,level2_medium/Gset_G56.bin +Gset_G58,level2_medium,5000,5000,59140,level2_medium/Gset_G58.bin +Gset_G60,level2_medium,7000,7000,34296,level2_medium/Gset_G60.bin +Gset_G61,level2_medium,7000,7000,34296,level2_medium/Gset_G61.bin +Gset_G63,level2_medium,7000,7000,82918,level2_medium/Gset_G63.bin +Gset_G64,level2_medium,7000,7000,82918,level2_medium/Gset_G64.bin +Gset_G66,level2_medium,9000,9000,36000,level2_medium/Gset_G66.bin +Guettel_TEM27623,level2_medium,27623,27623,439469,level2_medium/Guettel_TEM27623.bin +HB_bcsstk28,level2_medium,4410,4410,219024,level2_medium/HB_bcsstk28.bin +HB_bcsstk30,level2_medium,28924,28924,2043492,level2_medium/HB_bcsstk30.bin +HB_gemat11,level2_medium,4929,4929,33185,level2_medium/HB_gemat11.bin +HB_gemat12,level2_medium,4929,4929,33111,level2_medium/HB_gemat12.bin +HB_lns_3937,level2_medium,3937,3937,25407,level2_medium/HB_lns_3937.bin +HB_lock3491,level2_medium,3491,3491,160444,level2_medium/HB_lock3491.bin +HB_sherman3,level2_medium,5005,5005,20033,level2_medium/HB_sherman3.bin +HB_sherman5,level2_medium,3312,3312,20793,level2_medium/HB_sherman5.bin +Hohn_fd12,level2_medium,7500,7500,28462,level2_medium/Hohn_fd12.bin +Hohn_fd15,level2_medium,11532,11532,44206,level2_medium/Hohn_fd15.bin +Hohn_sinc15,level2_medium,11532,11532,568526,level2_medium/Hohn_sinc15.bin +Hohn_sinc18,level2_medium,16428,16428,973826,level2_medium/Hohn_sinc18.bin +Hollinger_g7jac100sc,level2_medium,29610,29610,384636,level2_medium/Hollinger_g7jac100sc.bin +IPSO_OPF_3754,level2_medium,15435,15435,158273,level2_medium/IPSO_OPF_3754.bin +IPSO_OPF_6000,level2_medium,29902,29902,302418,level2_medium/IPSO_OPF_6000.bin +IPSO_TSC_OPF_1047,level2_medium,8140,8140,2016902,level2_medium/IPSO_TSC_OPF_1047.bin +IPSO_TSC_OPF_300,level2_medium,9774,9774,820804,level2_medium/IPSO_TSC_OPF_300.bin +JGD_Forest_TF16,level2_medium,15437,19321,216173,level2_medium/JGD_Forest_TF16.bin +JGD_Franz_Franz4,level2_medium,6784,5252,46528,level2_medium/JGD_Franz_Franz4.bin +JGD_Franz_Franz7,level2_medium,10164,1740,40424,level2_medium/JGD_Franz_Franz7.bin +JGD_G5_IG5-14,level2_medium,6735,7621,173337,level2_medium/JGD_G5_IG5-14.bin +JGD_G5_IG5-15,level2_medium,11369,11987,323509,level2_medium/JGD_G5_IG5-15.bin +JGD_G5_IG5-17,level2_medium,30162,27944,1035008,level2_medium/JGD_G5_IG5-17.bin +JGD_GL7d_GL7d13,level2_medium,47271,8899,356232,level2_medium/JGD_GL7d_GL7d13.bin +JGD_Homology_mk12-b3,level2_medium,51975,13860,207900,level2_medium/JGD_Homology_mk12-b3.bin +JGD_Homology_n2c6-b6,level2_medium,5715,4945,40005,level2_medium/JGD_Homology_n2c6-b6.bin +JGD_SPG_EX5,level2_medium,6545,6545,295680,level2_medium/JGD_SPG_EX5.bin +JGD_Trefethen_Trefethen_20000,level2_medium,20000,20000,554466,level2_medium/JGD_Trefethen_Trefethen_20000.bin +JGD_Trefethen_Trefethen_20000b,level2_medium,19999,19999,554435,level2_medium/JGD_Trefethen_Trefethen_20000b.bin +LPnetlib_lp_maros_r7,level2_medium,3136,9408,144848,level2_medium/LPnetlib_lp_maros_r7.bin +LPnetlib_lp_osa_14,level2_medium,2337,54797,317097,level2_medium/LPnetlib_lp_osa_14.bin +LPnetlib_lp_qap15,level2_medium,6330,22275,94950,level2_medium/LPnetlib_lp_qap15.bin +Li_li,level2_medium,22695,22695,1350309,level2_medium/Li_li.bin +LiuWenzhuo_powersim,level2_medium,15838,15838,67562,level2_medium/LiuWenzhuo_powersim.bin +MKS_fp,level2_medium,7548,7548,848553,level2_medium/MKS_fp.bin +ML_Graph_har_10NN,level2_medium,10299,10299,151736,level2_medium/ML_Graph_har_10NN.bin +ML_Graph_optdigits_10NN,level2_medium,5620,5620,79650,level2_medium/ML_Graph_optdigits_10NN.bin +ML_Graph_usps_norm_5NN,level2_medium,11000,11000,81112,level2_medium/ML_Graph_usps_norm_5NN.bin +Mallya_lhr04c,level2_medium,4101,4101,82682,level2_medium/Mallya_lhr04c.bin +Mallya_lhr07,level2_medium,7337,7337,156508,level2_medium/Mallya_lhr07.bin +Mallya_lhr07c,level2_medium,7337,7337,156508,level2_medium/Mallya_lhr07c.bin +Mallya_lhr10,level2_medium,10672,10672,232633,level2_medium/Mallya_lhr10.bin +Mallya_lhr11,level2_medium,10964,10964,233741,level2_medium/Mallya_lhr11.bin +Mallya_lhr11c,level2_medium,10964,10964,233741,level2_medium/Mallya_lhr11c.bin +Mallya_lhr14,level2_medium,14270,14270,307858,level2_medium/Mallya_lhr14.bin +Mallya_lhr14c,level2_medium,14270,14270,307858,level2_medium/Mallya_lhr14c.bin +Mallya_lhr17,level2_medium,17576,17576,381975,level2_medium/Mallya_lhr17.bin +Mallya_lhr17c,level2_medium,17576,17576,381975,level2_medium/Mallya_lhr17c.bin +MathWorks_Kaufhold,level2_medium,8765,8765,42471,level2_medium/MathWorks_Kaufhold.bin +MathWorks_Pd,level2_medium,8081,8081,13036,level2_medium/MathWorks_Pd.bin +Meszaros_co9,level2_medium,10789,22924,109651,level2_medium/Meszaros_co9.bin +Meszaros_dbir1,level2_medium,18804,45775,1077025,level2_medium/Meszaros_dbir1.bin +Meszaros_dbir2,level2_medium,18906,45877,1158159,level2_medium/Meszaros_dbir2.bin +Meszaros_nemsemm1,level2_medium,3945,75352,1053986,level2_medium/Meszaros_nemsemm1.bin +Meszaros_nsir,level2_medium,4453,10057,154939,level2_medium/Meszaros_nsir.bin +Meszaros_r05,level2_medium,5190,9690,104145,level2_medium/Meszaros_r05.bin +Meszaros_rat,level2_medium,3136,9408,268908,level2_medium/Meszaros_rat.bin +Meszaros_scsd8-2b,level2_medium,5130,35910,112770,level2_medium/Meszaros_scsd8-2b.bin +Meszaros_scsd8-2c,level2_medium,5130,35910,112770,level2_medium/Meszaros_scsd8-2c.bin +Meszaros_scsd8-2r,level2_medium,8650,60550,190210,level2_medium/Meszaros_scsd8-2r.bin +Meszaros_stat96v4,level2_medium,3173,63076,491336,level2_medium/Meszaros_stat96v4.bin +Meszaros_stat96v5,level2_medium,2307,75779,233921,level2_medium/Meszaros_stat96v5.bin +Muite_Chebyshev3,level2_medium,4101,4101,36879,level2_medium/Muite_Chebyshev3.bin +Mycielski_mycielskian13,level2_medium,6143,6143,1227742,level2_medium/Mycielski_mycielskian13.bin +ND_nd3k,level2_medium,9000,9000,3279690,level2_medium/ND_nd3k.bin +NYPA_Maragal_6,level2_medium,21255,10152,537694,level2_medium/NYPA_Maragal_6.bin +Nasa_barth,level2_medium,6691,6691,26439,level2_medium/Nasa_barth.bin +Nasa_barth5,level2_medium,15606,15606,61484,level2_medium/Nasa_barth5.bin +Nasa_shuttle_eddy,level2_medium,10429,10429,103599,level2_medium/Nasa_shuttle_eddy.bin +Nemeth_nemeth01,level2_medium,9506,9506,725054,level2_medium/Nemeth_nemeth01.bin +Nemeth_nemeth02,level2_medium,9506,9506,394808,level2_medium/Nemeth_nemeth02.bin +Nemeth_nemeth06,level2_medium,9506,9506,394808,level2_medium/Nemeth_nemeth06.bin +Nemeth_nemeth07,level2_medium,9506,9506,394812,level2_medium/Nemeth_nemeth07.bin +Nemeth_nemeth09,level2_medium,9506,9506,395506,level2_medium/Nemeth_nemeth09.bin +Nemeth_nemeth10,level2_medium,9506,9506,401448,level2_medium/Nemeth_nemeth10.bin +Nemeth_nemeth11,level2_medium,9506,9506,408264,level2_medium/Nemeth_nemeth11.bin +Nemeth_nemeth15,level2_medium,9506,9506,539802,level2_medium/Nemeth_nemeth15.bin +Nemeth_nemeth17,level2_medium,9506,9506,629620,level2_medium/Nemeth_nemeth17.bin +Nemeth_nemeth19,level2_medium,9506,9506,818302,level2_medium/Nemeth_nemeth19.bin +Nemeth_nemeth20,level2_medium,9506,9506,971870,level2_medium/Nemeth_nemeth20.bin +Nemeth_nemeth22,level2_medium,9506,9506,1358832,level2_medium/Nemeth_nemeth22.bin +Nemeth_nemeth24,level2_medium,9506,9506,1506550,level2_medium/Nemeth_nemeth24.bin +Nemeth_nemeth25,level2_medium,9506,9506,1511758,level2_medium/Nemeth_nemeth25.bin +Newman_as-22july06,level2_medium,22963,22963,96872,level2_medium/Newman_as-22july06.bin +Newman_power,level2_medium,4941,4941,13188,level2_medium/Newman_power.bin +Norris_fv1,level2_medium,9604,9604,85264,level2_medium/Norris_fv1.bin +Norris_heart1,level2_medium,3557,3557,1387773,level2_medium/Norris_heart1.bin +Oberwolfach_chipcool0,level2_medium,20082,20082,281150,level2_medium/Oberwolfach_chipcool0.bin +Oberwolfach_gyro,level2_medium,17361,17361,1021159,level2_medium/Oberwolfach_gyro.bin +Oberwolfach_gyro_k,level2_medium,17361,17361,1021159,level2_medium/Oberwolfach_gyro_k.bin +Oberwolfach_t2dah_a,level2_medium,11445,11445,176117,level2_medium/Oberwolfach_t2dah_a.bin +Oberwolfach_t2dal_a,level2_medium,4257,4257,37465,level2_medium/Oberwolfach_t2dal_a.bin +Oberwolfach_t3dl,level2_medium,20360,20360,509866,level2_medium/Oberwolfach_t3dl.bin +Oberwolfach_t3dl_a,level2_medium,20360,20360,509866,level2_medium/Oberwolfach_t3dl_a.bin +Oberwolfach_t3dl_e,level2_medium,20360,20360,20360,level2_medium/Oberwolfach_t3dl_e.bin +Okunbor_aft01,level2_medium,8205,8205,125567,level2_medium/Okunbor_aft01.bin +PARSEC_Na5,level2_medium,5832,5832,305630,level2_medium/PARSEC_Na5.bin +PARSEC_Si10H16,level2_medium,17077,17077,875923,level2_medium/PARSEC_Si10H16.bin +PARSEC_Si5H12,level2_medium,19896,19896,738598,level2_medium/PARSEC_Si5H12.bin +PARSEC_SiH4,level2_medium,5041,5041,171903,level2_medium/PARSEC_SiH4.bin +PARSEC_benzene,level2_medium,8219,8219,242669,level2_medium/PARSEC_benzene.bin +POLYFLOW_invextr1_new,level2_medium,30412,30412,1793881,level2_medium/POLYFLOW_invextr1_new.bin +POLYFLOW_mixtank_new,level2_medium,29957,29957,1995041,level2_medium/POLYFLOW_mixtank_new.bin +Pajek_EAT_RS,level2_medium,23219,23219,325592,level2_medium/Pajek_EAT_RS.bin +Pajek_Erdos02,level2_medium,6927,6927,16944,level2_medium/Pajek_Erdos02.bin +Pajek_Erdos972,level2_medium,5488,5488,14170,level2_medium/Pajek_Erdos972.bin +Pajek_Erdos982,level2_medium,5822,5822,14750,level2_medium/Pajek_Erdos982.bin +Pajek_Erdos992,level2_medium,6100,6100,15030,level2_medium/Pajek_Erdos992.bin +Pajek_FA,level2_medium,10617,10617,72176,level2_medium/Pajek_FA.bin +Pajek_Kohonen,level2_medium,4470,4470,12731,level2_medium/Pajek_Kohonen.bin +Pajek_Lederberg,level2_medium,8843,8843,41601,level2_medium/Pajek_Lederberg.bin +Pajek_Reuters911,level2_medium,13332,13332,296076,level2_medium/Pajek_Reuters911.bin +Pajek_Zewail,level2_medium,6752,6752,54233,level2_medium/Pajek_Zewail.bin +Pajek_foldoc,level2_medium,13356,13356,120238,level2_medium/Pajek_foldoc.bin +Pajek_geom,level2_medium,7343,7343,23796,level2_medium/Pajek_geom.bin +Pothen_barth,level2_medium,6691,6691,46187,level2_medium/Pothen_barth.bin +Pothen_barth5,level2_medium,15606,15606,107362,level2_medium/Pothen_barth5.bin +Pothen_bodyy4,level2_medium,17546,17546,121938,level2_medium/Pothen_bodyy4.bin +Pothen_bodyy6,level2_medium,19366,19366,134748,level2_medium/Pothen_bodyy6.bin +Pothen_tandem_vtx,level2_medium,18454,18454,253350,level2_medium/Pothen_tandem_vtx.bin +Puri_ABACUS_shell_ud,level2_medium,23412,23412,218484,level2_medium/Puri_ABACUS_shell_ud.bin +QY_case9,level2_medium,14454,14454,147972,level2_medium/QY_case9.bin +Rommes_bips98_1450,level2_medium,11305,11305,1450,level2_medium/Rommes_bips98_1450.bin +SNAP_Oregon-1,level2_medium,11492,11492,44986,level2_medium/SNAP_Oregon-1.bin +SNAP_Oregon-2,level2_medium,11806,11806,65460,level2_medium/SNAP_Oregon-2.bin +SNAP_as-caida,level2_medium,31379,31379,106762,level2_medium/SNAP_as-caida.bin +SNAP_ca-AstroPh,level2_medium,18772,18772,396160,level2_medium/SNAP_ca-AstroPh.bin +SNAP_ca-HepPh,level2_medium,12008,12008,237010,level2_medium/SNAP_ca-HepPh.bin +SNAP_p2p-Gnutella04,level2_medium,10879,10879,39994,level2_medium/SNAP_p2p-Gnutella04.bin +SNAP_p2p-Gnutella05,level2_medium,8846,8846,31839,level2_medium/SNAP_p2p-Gnutella05.bin +SNAP_p2p-Gnutella06,level2_medium,8717,8717,31525,level2_medium/SNAP_p2p-Gnutella06.bin +SNAP_p2p-Gnutella08,level2_medium,6301,6301,20777,level2_medium/SNAP_p2p-Gnutella08.bin +SNAP_p2p-Gnutella09,level2_medium,8114,8114,26013,level2_medium/SNAP_p2p-Gnutella09.bin +SNAP_p2p-Gnutella24,level2_medium,26518,26518,65369,level2_medium/SNAP_p2p-Gnutella24.bin +SNAP_soc-sign-bitcoin-alpha,level2_medium,3783,3783,24186,level2_medium/SNAP_soc-sign-bitcoin-alpha.bin +SNAP_soc-sign-bitcoin-otc,level2_medium,5881,5881,35592,level2_medium/SNAP_soc-sign-bitcoin-otc.bin +SNAP_sx-mathoverflow,level2_medium,24818,24818,239978,level2_medium/SNAP_sx-mathoverflow.bin +SNAP_wiki-RfA,level2_medium,11380,11380,188077,level2_medium/SNAP_wiki-RfA.bin +Schenk_IBMNA_c-30,level2_medium,5321,5321,65693,level2_medium/Schenk_IBMNA_c-30.bin +Schenk_IBMNA_c-31,level2_medium,5339,5339,78571,level2_medium/Schenk_IBMNA_c-31.bin +Schenk_IBMNA_c-33,level2_medium,6317,6317,56123,level2_medium/Schenk_IBMNA_c-33.bin +Schenk_IBMNA_c-40,level2_medium,9941,9941,81501,level2_medium/Schenk_IBMNA_c-40.bin +Schenk_IBMNA_c-41,level2_medium,9769,9769,101745,level2_medium/Schenk_IBMNA_c-41.bin +Schenk_IBMNA_c-43,level2_medium,11125,11125,123675,level2_medium/Schenk_IBMNA_c-43.bin +Schenk_IBMNA_c-45,level2_medium,13206,13206,174452,level2_medium/Schenk_IBMNA_c-45.bin +Schenk_IBMNA_c-47,level2_medium,15343,15343,211401,level2_medium/Schenk_IBMNA_c-47.bin +Schenk_IBMNA_c-49,level2_medium,21132,21132,157042,level2_medium/Schenk_IBMNA_c-49.bin +Schenk_IBMNA_c-50,level2_medium,22401,22401,193625,level2_medium/Schenk_IBMNA_c-50.bin +Schenk_IBMNA_c-51,level2_medium,23196,23196,203050,level2_medium/Schenk_IBMNA_c-51.bin +Schenk_IBMNA_c-53,level2_medium,30235,30235,372213,level2_medium/Schenk_IBMNA_c-53.bin +Schenk_IBMSDS_2D_27628_bjtcai,level2_medium,27628,27628,442898,level2_medium/Schenk_IBMSDS_2D_27628_bjtcai.bin +Schenk_ISEI_igbt3,level2_medium,10938,10938,234006,level2_medium/Schenk_ISEI_igbt3.bin +Schulthess_N_reactome,level2_medium,10204,16559,43816,level2_medium/Schulthess_N_reactome.bin +Shen_e40r0100,level2_medium,17281,17281,553562,level2_medium/Shen_e40r0100.bin +Shen_shermanACd,level2_medium,6136,6136,53329,level2_medium/Shen_shermanACd.bin +Simon_olafu,level2_medium,16146,16146,1015156,level2_medium/Simon_olafu.bin +Simon_raefsky1,level2_medium,3242,3242,294276,level2_medium/Simon_raefsky1.bin +Simon_raefsky2,level2_medium,3242,3242,294276,level2_medium/Simon_raefsky2.bin +Simon_raefsky3,level2_medium,21200,21200,1488768,level2_medium/Simon_raefsky3.bin +Simon_raefsky6,level2_medium,3402,3402,137845,level2_medium/Simon_raefsky6.bin +TAMU_SmartGridCenter_ACTIVSg2000,level2_medium,4000,4000,29336,level2_medium/TAMU_SmartGridCenter_ACTIVSg2000.bin +TKK_t2d_q4,level2_medium,9801,9801,87025,level2_medium/TKK_t2d_q4.bin +TKK_tube1,level2_medium,21498,21498,897056,level2_medium/TKK_tube1.bin +TKK_tube2,level2_medium,21498,21498,897056,level2_medium/TKK_tube2.bin +TOKAMAK_utm5940,level2_medium,5940,5940,83842,level2_medium/TOKAMAK_utm5940.bin +TSOPF_TSOPF_FS_b162_c1,level2_medium,10798,10798,608540,level2_medium/TSOPF_TSOPF_FS_b162_c1.bin +TSOPF_TSOPF_RS_b162_c1,level2_medium,5374,5374,205399,level2_medium/TSOPF_TSOPF_RS_b162_c1.bin +TSOPF_TSOPF_RS_b162_c3,level2_medium,15374,15374,610299,level2_medium/TSOPF_TSOPF_RS_b162_c3.bin +TSOPF_TSOPF_RS_b162_c4,level2_medium,20374,20374,812749,level2_medium/TSOPF_TSOPF_RS_b162_c4.bin +TSOPF_TSOPF_RS_b2052_c1,level2_medium,25626,25626,6761100,level2_medium/TSOPF_TSOPF_RS_b2052_c1.bin +TSOPF_TSOPF_RS_b300_c1,level2_medium,14538,14538,1474325,level2_medium/TSOPF_TSOPF_RS_b300_c1.bin +TSOPF_TSOPF_RS_b300_c2,level2_medium,28338,28338,2943887,level2_medium/TSOPF_TSOPF_RS_b300_c2.bin +VDOL_dynamicSoaringProblem_7,level2_medium,3511,3511,37680,level2_medium/VDOL_dynamicSoaringProblem_7.bin +VDOL_freeFlyingRobot_11,level2_medium,5438,5438,40054,level2_medium/VDOL_freeFlyingRobot_11.bin +VDOL_hangGlider_5,level2_medium,16011,16011,155246,level2_medium/VDOL_hangGlider_5.bin +VDOL_kineticBatchReactor_6,level2_medium,7773,7773,82500,level2_medium/VDOL_kineticBatchReactor_6.bin +VDOL_lowThrust_11,level2_medium,18368,18368,223801,level2_medium/VDOL_lowThrust_11.bin +VDOL_lowThrust_4,level2_medium,13562,13562,160947,level2_medium/VDOL_lowThrust_4.bin +VanVelzen_Zd_Jac2,level2_medium,22835,22835,1642833,level2_medium/VanVelzen_Zd_Jac2.bin +VanVelzen_Zd_Jac2_db,level2_medium,22835,22835,676439,level2_medium/VanVelzen_Zd_Jac2_db.bin +VanVelzen_Zd_Jac3,level2_medium,22835,22835,1916152,level2_medium/VanVelzen_Zd_Jac3.bin +VanVelzen_Zd_Jac3_db,level2_medium,22835,22835,713907,level2_medium/VanVelzen_Zd_Jac3_db.bin +VanVelzen_Zd_Jac6,level2_medium,22835,22835,1711983,level2_medium/VanVelzen_Zd_Jac6.bin +VanVelzen_Zd_Jac6_db,level2_medium,22835,22835,663643,level2_medium/VanVelzen_Zd_Jac6_db.bin +VanVelzen_std1_Jac2,level2_medium,21982,21982,1248731,level2_medium/VanVelzen_std1_Jac2.bin +VanVelzen_std1_Jac2_db,level2_medium,21982,21982,498771,level2_medium/VanVelzen_std1_Jac2_db.bin +VanVelzen_std1_Jac3_db,level2_medium,21982,21982,531826,level2_medium/VanVelzen_std1_Jac3_db.bin +Wang_swang1,level2_medium,3169,3169,20841,level2_medium/Wang_swang1.bin +Wang_swang2,level2_medium,3169,3169,20841,level2_medium/Wang_swang2.bin +Zitney_hydr1c,level2_medium,5308,5308,23752,level2_medium/Zitney_hydr1c.bin +Zitney_rdist1,level2_medium,4134,4134,94408,level2_medium/Zitney_rdist1.bin +Zitney_rdist2,level2_medium,3198,3198,56934,level2_medium/Zitney_rdist2.bin +vanHeukelum_cage10,level2_medium,11397,11397,150645,level2_medium/vanHeukelum_cage10.bin +vanHeukelum_cage9,level2_medium,3534,3534,41594,level2_medium/vanHeukelum_cage9.bin +AG-Monien_bfly,level3_large,49152,49152,196608,level3_large/AG-Monien_bfly.bin +AG-Monien_brack2,level3_large,62631,62631,733118,level3_large/AG-Monien_brack2.bin +AG-Monien_ccc,level3_large,49152,49152,147456,level3_large/AG-Monien_ccc.bin +ATandT_onetone1,level3_large,36057,36057,341088,level3_large/ATandT_onetone1.bin +ATandT_onetone2,level3_large,36057,36057,227628,level3_large/ATandT_onetone2.bin +Andrianov_net125,level3_large,36720,36720,2577200,level3_large/Andrianov_net125.bin +Andrianov_net4-1,level3_large,88343,88343,2441727,level3_large/Andrianov_net4-1.bin +Averous_epb3,level3_large,84617,84617,463625,level3_large/Averous_epb3.bin +Barabasi_NotreDame_actors,level3_large,392400,127823,1470404,level3_large/Barabasi_NotreDame_actors.bin +Bomhof_circuit_4,level3_large,80209,80209,307604,level3_large/Bomhof_circuit_4.bin +Botonakis_FEM_3D_thermal2,level3_large,147900,147900,3489300,level3_large/Botonakis_FEM_3D_thermal2.bin +Botonakis_thermomech_TC,level3_large,102158,102158,711558,level3_large/Botonakis_thermomech_TC.bin +Botonakis_thermomech_dK,level3_large,204316,204316,2846228,level3_large/Botonakis_thermomech_dK.bin +Bova_rma10,level3_large,46835,46835,2374001,level3_large/Bova_rma10.bin +Bydder_mri1,level3_large,65536,147456,589824,level3_large/Bydder_mri1.bin +Castrillon_denormal,level3_large,89400,89400,1156224,level3_large/Castrillon_denormal.bin +Chen_pkustk06,level3_large,43164,43164,2571768,level3_large/Chen_pkustk06.bin +Chen_pkustk09,level3_large,33960,33960,1583640,level3_large/Chen_pkustk09.bin +Chen_pkustk10,level3_large,80676,80676,4308984,level3_large/Chen_pkustk10.bin +Chen_pkustk11,level3_large,87804,87804,5217912,level3_large/Chen_pkustk11.bin +Clark_tomographic1,level3_large,73159,59498,647495,level3_large/Clark_tomographic1.bin +Cunningham_qa8fk,level3_large,66127,66127,1660579,level3_large/Cunningham_qa8fk.bin +DIMACS10_G_n_pin_pout,level3_large,100000,100000,1002396,level3_large/DIMACS10_G_n_pin_pout.bin +DIMACS10_al2010,level3_large,252266,252266,1230482,level3_large/DIMACS10_al2010.bin +DIMACS10_caidaRouterLevel,level3_large,192244,192244,1218132,level3_large/DIMACS10_caidaRouterLevel.bin +DIMACS10_coAuthorsCiteseer,level3_large,227320,227320,1628268,level3_large/DIMACS10_coAuthorsCiteseer.bin +DIMACS10_fe_body,level3_large,45087,45087,327468,level3_large/DIMACS10_fe_body.bin +DIMACS10_fe_rotor,level3_large,99617,99617,1324862,level3_large/DIMACS10_fe_rotor.bin +DIMACS10_fe_tooth,level3_large,78136,78136,905182,level3_large/DIMACS10_fe_tooth.bin +DIMACS10_ia2010,level3_large,216007,216007,1021170,level3_large/DIMACS10_ia2010.bin +DIMACS10_luxembourg_osm,level3_large,114599,114599,239332,level3_large/DIMACS10_luxembourg_osm.bin +DIMACS10_md2010,level3_large,145247,145247,700378,level3_large/DIMACS10_md2010.bin +DIMACS10_nd2010,level3_large,133769,133769,625946,level3_large/DIMACS10_nd2010.bin +DIMACS10_preferentialAttachment,level3_large,100000,100000,999970,level3_large/DIMACS10_preferentialAttachment.bin +DIMACS10_rgg_n_2_15_s0,level3_large,32768,32768,320480,level3_large/DIMACS10_rgg_n_2_15_s0.bin +DIMACS10_rgg_n_2_16_s0,level3_large,65536,65536,684254,level3_large/DIMACS10_rgg_n_2_16_s0.bin +DIMACS10_rgg_n_2_17_s0,level3_large,131072,131072,1457506,level3_large/DIMACS10_rgg_n_2_17_s0.bin +DIMACS10_rgg_n_2_18_s0,level3_large,262144,262144,3094566,level3_large/DIMACS10_rgg_n_2_18_s0.bin +DIMACS10_smallworld,level3_large,100000,100000,999996,level3_large/DIMACS10_smallworld.bin +DIMACS10_vsp_bcsstk30_500sep_10in_1Kout,level3_large,58348,58348,4033156,level3_large/DIMACS10_vsp_bcsstk30_500sep_10in_1Kout.bin +DIMACS10_vsp_sctap1-2b_and_seymourl,level3_large,40174,40174,281662,level3_large/DIMACS10_vsp_sctap1-2b_and_seymourl.bin +DIMACS10_vsp_vibrobox_scagr7-2c_rlfddd,level3_large,77328,77328,871172,level3_large/DIMACS10_vsp_vibrobox_scagr7-2c_rlfddd.bin +DNVS_ship_001,level3_large,34920,34920,4644230,level3_large/DNVS_ship_001.bin +DNVS_ship_003,level3_large,121728,121728,8086034,level3_large/DNVS_ship_003.bin +Dattorro_EternityII_E,level3_large,11077,262144,1503732,level3_large/Dattorro_EternityII_E.bin +Embree_ifiss_mat,level3_large,96307,96307,3599932,level3_large/Embree_ifiss_mat.bin +FlowIPM22_uni_chimera_i3,level3_large,100000,100000,499696,level3_large/FlowIPM22_uni_chimera_i3.bin +FlowIPM22_uni_chimera_i4,level3_large,100000,100000,814436,level3_large/FlowIPM22_uni_chimera_i4.bin +FlowIPM22_uni_chimera_i5,level3_large,100000,100000,499982,level3_large/FlowIPM22_uni_chimera_i5.bin +Fluorem_PR02R,level3_large,161070,161070,8185136,level3_large/Fluorem_PR02R.bin +GHS_indef_a0nsdsil,level3_large,80016,80016,355034,level3_large/GHS_indef_a0nsdsil.bin +GHS_indef_aug3dcqp,level3_large,35543,35543,128115,level3_large/GHS_indef_aug3dcqp.bin +GHS_indef_bmw3_2,level3_large,227362,227362,11288630,level3_large/GHS_indef_bmw3_2.bin +GHS_indef_c-58,level3_large,37595,37595,552557,level3_large/GHS_indef_c-58.bin +GHS_indef_c-63,level3_large,44234,44234,434704,level3_large/GHS_indef_c-63.bin +GHS_indef_c-68,level3_large,64810,64810,566006,level3_large/GHS_indef_c-68.bin +GHS_indef_c-70,level3_large,68924,68924,658986,level3_large/GHS_indef_c-70.bin +GHS_indef_c-72,level3_large,84064,84064,707558,level3_large/GHS_indef_c-72.bin +GHS_indef_dawson5,level3_large,51537,51537,1010777,level3_large/GHS_indef_dawson5.bin +GHS_indef_ncvxqp7,level3_large,87500,87500,574962,level3_large/GHS_indef_ncvxqp7.bin +GHS_indef_stokes128,level3_large,49666,49666,558594,level3_large/GHS_indef_stokes128.bin +GHS_psdef_bmw7st_1,level3_large,141347,141347,7339667,level3_large/GHS_psdef_bmw7st_1.bin +GHS_psdef_copter2,level3_large,55476,55476,759952,level3_large/GHS_psdef_copter2.bin +GHS_psdef_oilpan,level3_large,73752,73752,3597188,level3_large/GHS_psdef_oilpan.bin +GHS_psdef_pwt,level3_large,36519,36519,326107,level3_large/GHS_psdef_pwt.bin +GHS_psdef_torsion1,level3_large,40000,40000,197608,level3_large/GHS_psdef_torsion1.bin +GHS_psdef_wathen120,level3_large,36441,36441,565761,level3_large/GHS_psdef_wathen120.bin +Gleich_usroads-48,level3_large,126146,126146,323900,level3_large/Gleich_usroads-48.bin +Gleich_usroads,level3_large,129164,129164,330870,level3_large/Gleich_usroads.bin +Goodwin_Goodwin_054,level3_large,32510,32510,1030878,level3_large/Goodwin_Goodwin_054.bin +Goodwin_Goodwin_071,level3_large,56021,56021,1797934,level3_large/Goodwin_Goodwin_071.bin +Goodwin_Goodwin_127,level3_large,178437,178437,5778545,level3_large/Goodwin_Goodwin_127.bin +Grund_bayer01,level3_large,57735,57735,277774,level3_large/Grund_bayer01.bin +Grund_poli4,level3_large,33833,33833,73249,level3_large/Grund_poli4.bin +Guettel_TEM152078,level3_large,152078,152078,6459326,level3_large/Guettel_TEM152078.bin +Guettel_TEM181302,level3_large,181302,181302,7839010,level3_large/Guettel_TEM181302.bin +Hamm_bcircuit,level3_large,68902,68902,375558,level3_large/Hamm_bcircuit.bin +Hollinger_g7jac140sc,level3_large,41490,41490,565956,level3_large/Hollinger_g7jac140sc.bin +Hollinger_g7jac160sc,level3_large,47430,47430,656616,level3_large/Hollinger_g7jac160sc.bin +Hollinger_mark3jac100,level3_large,45769,45769,285215,level3_large/Hollinger_mark3jac100.bin +Hollinger_mark3jac120sc,level3_large,54929,54929,342475,level3_large/Hollinger_mark3jac120sc.bin +Hollinger_mark3jac140,level3_large,64089,64089,399735,level3_large/Hollinger_mark3jac140.bin +IPSO_HTC_336_9129,level3_large,226340,226340,883422,level3_large/IPSO_HTC_336_9129.bin +IPSO_OPF_10000,level3_large,43887,43887,467711,level3_large/IPSO_OPF_10000.bin +JGD_GL7d_GL7d23,level3_large,105054,349443,2695430,level3_large/JGD_GL7d_GL7d23.bin +JGD_GL7d_GL7d24,level3_large,21074,105054,593892,level3_large/JGD_GL7d_GL7d24.bin +JGD_Homology_n4c6-b10,level3_large,132402,186558,1456422,level3_large/JGD_Homology_n4c6-b10.bin +JGD_Homology_n4c6-b12,level3_large,25605,69235,332865,level3_large/JGD_Homology_n4c6-b12.bin +JGD_Homology_n4c6-b5,level3_large,51813,20058,310878,level3_large/JGD_Homology_n4c6-b5.bin +JGD_Homology_n4c6-b6,level3_large,104115,51813,728805,level3_large/JGD_Homology_n4c6-b6.bin +JGD_Homology_n4c6-b9,level3_large,186558,198895,1865580,level3_large/JGD_Homology_n4c6-b9.bin +JGD_Homology_shar_te2-b2,level3_large,200200,17160,600600,level3_large/JGD_Homology_shar_te2-b2.bin +JGD_Homology_shar_te2-b3,level3_large,200200,200200,800800,level3_large/JGD_Homology_shar_te2-b3.bin +Kamvar_Stanford,level3_large,281903,281903,2312497,level3_large/Kamvar_Stanford.bin +Kim_kim1,level3_large,38415,38415,933195,level3_large/Kim_kim1.bin +LAW_enron,level3_large,69244,69244,276143,level3_large/LAW_enron.bin +ML_Graph_k49_norm_10NN,level3_large,38547,38547,618158,level3_large/ML_Graph_k49_norm_10NN.bin +Mallya_lhr34,level3_large,35152,35152,764014,level3_large/Mallya_lhr34.bin +Mallya_lhr34c,level3_large,35152,35152,764014,level3_large/Mallya_lhr34c.bin +Mallya_lhr71,level3_large,70304,70304,1528092,level3_large/Mallya_lhr71.bin +Mallya_lhr71c,level3_large,70304,70304,1528092,level3_large/Mallya_lhr71c.bin +Mancktelow_viscorocks,level3_large,37762,37762,1162244,level3_large/Mancktelow_viscorocks.bin +MaxPlanck_shallow_water1,level3_large,81920,81920,327680,level3_large/MaxPlanck_shallow_water1.bin +McRae_ecology1,level3_large,1000000,1000000,4996000,level3_large/McRae_ecology1.bin +Meszaros_fxm3_16,level3_large,41340,85575,392252,level3_large/Meszaros_fxm3_16.bin +Meszaros_fxm4_6,level3_large,22400,47185,265442,level3_large/Meszaros_fxm4_6.bin +Meszaros_karted,level3_large,46502,133115,1770349,level3_large/Meszaros_karted.bin +Meszaros_pltexpa,level3_large,26894,70364,143059,level3_large/Meszaros_pltexpa.bin +Meszaros_rlfprim,level3_large,58866,62716,320591,level3_large/Meszaros_rlfprim.bin +Meszaros_stat96v3,level3_large,33841,1113780,3317736,level3_large/Meszaros_stat96v3.bin +Mittelmann_fome12,level3_large,24284,48920,142528,level3_large/Mittelmann_fome12.bin +Mittelmann_watson_1,level3_large,201155,386992,1055093,level3_large/Mittelmann_watson_1.bin +Muite_Chebyshev4,level3_large,68121,68121,5377761,level3_large/Muite_Chebyshev4.bin +Mulvey_pfinan512,level3_large,74752,74752,596992,level3_large/Mulvey_pfinan512.bin +NYPA_Maragal_7,level3_large,46845,26564,1200537,level3_large/NYPA_Maragal_7.bin +NYPA_Maragal_8,level3_large,33212,75077,1308415,level3_large/NYPA_Maragal_8.bin +Nasa_pwt,level3_large,36519,36519,326107,level3_large/Nasa_pwt.bin +Newman_cond-mat-2005,level3_large,40421,40421,351386,level3_large/Newman_cond-mat-2005.bin +Norris_lung2,level3_large,109460,109460,492564,level3_large/Norris_lung2.bin +Norris_torso3,level3_large,259156,259156,4429042,level3_large/Norris_torso3.bin +Oberwolfach_boneS01,level3_large,127224,127224,6715152,level3_large/Oberwolfach_boneS01.bin +Oberwolfach_gas_sensor,level3_large,66917,66917,1703365,level3_large/Oberwolfach_gas_sensor.bin +Oberwolfach_rail_79841,level3_large,79841,79841,553921,level3_large/Oberwolfach_rail_79841.bin +Oberwolfach_t3dh,level3_large,79171,79171,4352105,level3_large/Oberwolfach_t3dh.bin +Oberwolfach_t3dh_a,level3_large,79171,79171,4352105,level3_large/Oberwolfach_t3dh_a.bin +PARSEC_CO,level3_large,221119,221119,7666057,level3_large/PARSEC_CO.bin +PARSEC_Ga10As10H30,level3_large,113081,113081,6115633,level3_large/PARSEC_Ga10As10H30.bin +PARSEC_Ga19As19H42,level3_large,133123,133123,8884839,level3_large/PARSEC_Ga19As19H42.bin +PARSEC_Ge99H100,level3_large,112985,112985,8451395,level3_large/PARSEC_Ge99H100.bin +PARSEC_H2O,level3_large,67024,67024,2216736,level3_large/PARSEC_H2O.bin +PARSEC_Si34H36,level3_large,97569,97569,5156379,level3_large/PARSEC_Si34H36.bin +PARSEC_SiO,level3_large,33401,33401,1317655,level3_large/PARSEC_SiO.bin +Pothen_pwt,level3_large,36519,36519,326107,level3_large/Pothen_pwt.bin +Pothen_tandem_dual,level3_large,94069,94069,460493,level3_large/Pothen_tandem_dual.bin +PowerSystem_power197k,level3_large,197156,197156,3698357,level3_large/PowerSystem_power197k.bin +Qaplib_lp_nug30,level3_large,52260,379350,1567800,level3_large/Qaplib_lp_nug30.bin +Quaglino_viscoplastic2,level3_large,32769,32769,381326,level3_large/Quaglino_viscoplastic2.bin +Rajat_rajat15,level3_large,37261,37261,443573,level3_large/Rajat_rajat15.bin +Rajat_rajat20,level3_large,86916,86916,605045,level3_large/Rajat_rajat20.bin +Rajat_rajat23,level3_large,110355,110355,556938,level3_large/Rajat_rajat23.bin +Raju_laminar_duct3D,level3_large,67173,67173,3833077,level3_large/Raju_laminar_duct3D.bin +Rommes_bauru5727,level3_large,40366,40366,145019,level3_large/Rommes_bauru5727.bin +Rommes_juba40k,level3_large,40337,40337,144945,level3_large/Rommes_juba40k.bin +Rothberg_3dtube,level3_large,45330,45330,3213618,level3_large/Rothberg_3dtube.bin +Rothberg_cfd1,level3_large,70656,70656,1828364,level3_large/Rothberg_cfd1.bin +Rothberg_gearbox,level3_large,153746,153746,9080404,level3_large/Rothberg_gearbox.bin +SNAP_email-Enron,level3_large,36692,36692,367662,level3_large/SNAP_email-Enron.bin +SNAP_loc-Brightkite,level3_large,58228,58228,428156,level3_large/SNAP_loc-Brightkite.bin +SNAP_loc-Gowalla,level3_large,196591,196591,1900654,level3_large/SNAP_loc-Gowalla.bin +SNAP_p2p-Gnutella31,level3_large,62586,62586,147892,level3_large/SNAP_p2p-Gnutella31.bin +SNAP_soc-Epinions1,level3_large,75888,75888,508837,level3_large/SNAP_soc-Epinions1.bin +SNAP_soc-Slashdot0811,level3_large,77360,77360,905468,level3_large/SNAP_soc-Slashdot0811.bin +SNAP_soc-Slashdot0902,level3_large,82168,82168,948464,level3_large/SNAP_soc-Slashdot0902.bin +SNAP_soc-sign-Slashdot081106,level3_large,77357,77357,516575,level3_large/SNAP_soc-sign-Slashdot081106.bin +SNAP_soc-sign-Slashdot090216,level3_large,81871,81871,545671,level3_large/SNAP_soc-sign-Slashdot090216.bin +SNAP_soc-sign-Slashdot090221,level3_large,82144,82144,549202,level3_large/SNAP_soc-sign-Slashdot090221.bin +SNAP_soc-sign-epinions,level3_large,131828,131828,841372,level3_large/SNAP_soc-sign-epinions.bin +SNAP_sx-superuser,level3_large,194085,194085,924886,level3_large/SNAP_sx-superuser.bin +Sanghavi_ecl32,level3_large,51993,51993,380415,level3_large/Sanghavi_ecl32.bin +Schenk_IBMNA_c-57,level3_large,37833,37833,405197,level3_large/Schenk_IBMNA_c-57.bin +Schenk_IBMNA_c-60,level3_large,43640,43640,298578,level3_large/Schenk_IBMNA_c-60.bin +Schenk_IBMNA_c-61,level3_large,43618,43618,310016,level3_large/Schenk_IBMNA_c-61.bin +Schenk_IBMNA_c-62,level3_large,41731,41731,559343,level3_large/Schenk_IBMNA_c-62.bin +Schenk_IBMNA_c-66,level3_large,49989,49989,499007,level3_large/Schenk_IBMNA_c-66.bin +Schenk_IBMNA_c-66b,level3_large,49989,49989,499007,level3_large/Schenk_IBMNA_c-66b.bin +Schenk_IBMNA_c-67,level3_large,57975,57975,531935,level3_large/Schenk_IBMNA_c-67.bin +Schenk_IBMNA_c-67b,level3_large,57975,57975,531935,level3_large/Schenk_IBMNA_c-67b.bin +Schenk_IBMSDS_2D_54019_highK,level3_large,54019,54019,996414,level3_large/Schenk_IBMSDS_2D_54019_highK.bin +Schenk_IBMSDS_matrix-new_3,level3_large,125329,125329,2678750,level3_large/Schenk_IBMSDS_matrix-new_3.bin +Schenk_ISEI_barrier2-9,level3_large,115625,115625,3897557,level3_large/Schenk_ISEI_barrier2-9.bin +Schenk_ISEI_ohne2,level3_large,181343,181343,11063545,level3_large/Schenk_ISEI_ohne2.bin +Schenk_ISEI_para-10,level3_large,155924,155924,5416358,level3_large/Schenk_ISEI_para-10.bin +Schenk_ISEI_para-4,level3_large,153226,153226,5326228,level3_large/Schenk_ISEI_para-4.bin +Schenk_ISEI_para-9,level3_large,155924,155924,5416358,level3_large/Schenk_ISEI_para-9.bin +Schmid_thermal1,level3_large,82654,82654,574458,level3_large/Schmid_thermal1.bin +Simon_bbmat,level3_large,38744,38744,1771722,level3_large/Simon_bbmat.bin +Simon_venkat25,level3_large,62424,62424,1717792,level3_large/Simon_venkat25.bin +TKK_engine,level3_large,143571,143571,4706073,level3_large/TKK_engine.bin +TSOPF_TSOPF_RS_b2383,level3_large,38120,38120,16171169,level3_large/TSOPF_TSOPF_RS_b2383.bin +TSOPF_TSOPF_RS_b39_c30,level3_large,60098,60098,1079986,level3_large/TSOPF_TSOPF_RS_b39_c30.bin +TSOPF_TSOPF_RS_b678_c2,level3_large,35696,35696,8781949,level3_large/TSOPF_TSOPF_RS_b678_c2.bin +Toledo_deltaX,level3_large,68600,21961,247424,level3_large/Toledo_deltaX.bin +UTEP_Dubcova2,level3_large,65025,65025,1030225,level3_large/UTEP_Dubcova2.bin +UTEP_Dubcova3,level3_large,146689,146689,3636649,level3_large/UTEP_Dubcova3.bin +Um_offshore,level3_large,259789,259789,4242673,level3_large/Um_offshore.bin +VLSI_nv1,level3_large,75468,75468,2449194,level3_large/VLSI_nv1.bin +VLSI_power9,level3_large,155376,155376,2512300,level3_large/VLSI_power9.bin +VLSI_radiation,level3_large,223104,223104,7637688,level3_large/VLSI_radiation.bin +VLSI_ss1,level3_large,205282,205282,845089,level3_large/VLSI_ss1.bin +Vavasis_av41092,level3_large,41092,41092,1683902,level3_large/Vavasis_av41092.bin +Williams_cant,level3_large,62451,62451,4007383,level3_large/Williams_cant.bin +Williams_consph,level3_large,83334,83334,6010480,level3_large/Williams_consph.bin +Williams_mac_econ_fwd500,level3_large,206500,206500,1273389,level3_large/Williams_mac_econ_fwd500.bin +Williams_pdb1HYS,level3_large,36417,36417,4344765,level3_large/Williams_pdb1HYS.bin +Yoshiyasu_image_interp,level3_large,240000,120000,711683,level3_large/Yoshiyasu_image_interp.bin +Zhao_Zhao1,level3_large,33861,33861,166453,level3_large/Zhao_Zhao1.bin +vanHeukelum_cage11,level3_large,39082,39082,559722,level3_large/vanHeukelum_cage11.bin +vanHeukelum_cage12,level3_large,130228,130228,2032536,level3_large/vanHeukelum_cage12.bin +AG-Monien_debr,level4_huge,1048576,1048576,4194298,level4_huge/AG-Monien_debr.bin +ANSYS_Delor338K,level4_huge,343236,887058,4211599,level4_huge/ANSYS_Delor338K.bin +ANSYS_Delor64K,level4_huge,64719,1785345,652140,level4_huge/ANSYS_Delor64K.bin +ATandT_pre2,level4_huge,659033,659033,5959282,level4_huge/ATandT_pre2.bin +Bourchtein_atmosmodd,level4_huge,1270432,1270432,8814880,level4_huge/Bourchtein_atmosmodd.bin +CEMW_tmt_unsym,level4_huge,917825,917825,4584801,level4_huge/CEMW_tmt_unsym.bin +DIMACS10_NACA0015,level4_huge,1039183,1039183,6229636,level4_huge/DIMACS10_NACA0015.bin +DIMACS10_auto,level4_huge,448695,448695,6629222,level4_huge/DIMACS10_auto.bin +DIMACS10_delaunay_n24,level4_huge,16777216,16777216,100663202,level4_huge/DIMACS10_delaunay_n24.bin +DIMACS10_ny2010,level4_huge,350169,350169,1709544,level4_huge/DIMACS10_ny2010.bin +FlowIPM22_Spielman_k100,level4_huge,338402,338402,1025404,level4_huge/FlowIPM22_Spielman_k100.bin +Freescale_Freescale1,level4_huge,3428755,3428755,18920347,level4_huge/Freescale_Freescale1.bin +Freescale_circuit5M_dc,level4_huge,3523317,3523317,19194193,level4_huge/Freescale_circuit5M_dc.bin +Freescale_memchip,level4_huge,2707524,2707524,14810202,level4_huge/Freescale_memchip.bin +GHS_indef_helm2d03,level4_huge,392257,392257,2741935,level4_huge/GHS_indef_helm2d03.bin +GHS_indef_mario002,level4_huge,389874,389874,2101242,level4_huge/GHS_indef_mario002.bin +Hamrle_Hamrle3,level4_huge,1447360,1447360,5514242,level4_huge/Hamrle_Hamrle3.bin +Hardesty_Hardesty1,level4_huge,938905,938905,12143314,level4_huge/Hardesty_Hardesty1.bin +JGD_Margulies_kneser_10_4_1,level4_huge,349651,330751,992252,level4_huge/JGD_Margulies_kneser_10_4_1.bin +Janna_CoupCons3D,level4_huge,416800,416800,22322336,level4_huge/Janna_CoupCons3D.bin +Kamvar_Stanford_Berkeley,level4_huge,683446,683446,7583376,level4_huge/Kamvar_Stanford_Berkeley.bin +LAW_dblp-2010,level4_huge,326186,326186,1615400,level4_huge/LAW_dblp-2010.bin +Martin_marine1,level4_huge,400320,400320,6226538,level4_huge/Martin_marine1.bin +McRae_ecology2,level4_huge,999999,999999,4995991,level4_huge/McRae_ecology2.bin +Meszaros_degme,level4_huge,185501,659415,8127528,level4_huge/Meszaros_degme.bin +Pajek_IMDB,level4_huge,428440,896308,3782463,level4_huge/Pajek_IMDB.bin +SNAP_amazon0312,level4_huge,400727,400727,3200440,level4_huge/SNAP_amazon0312.bin +SNAP_amazon0505,level4_huge,410236,410236,3356824,level4_huge/SNAP_amazon0505.bin +SNAP_amazon0601,level4_huge,403394,403394,3387388,level4_huge/SNAP_amazon0601.bin +SNAP_com-Amazon,level4_huge,334863,334863,1851744,level4_huge/SNAP_com-Amazon.bin +SNAP_roadNet-CA,level4_huge,1971281,1971281,5533214,level4_huge/SNAP_roadNet-CA.bin +SNAP_roadNet-PA,level4_huge,1090920,1090920,3083796,level4_huge/SNAP_roadNet-PA.bin +SNAP_roadNet-TX,level4_huge,1393383,1393383,3843320,level4_huge/SNAP_roadNet-TX.bin +SNAP_web-BerkStan,level4_huge,685230,685230,7600595,level4_huge/SNAP_web-BerkStan.bin +SNAP_web-Google,level4_huge,916428,916428,5105039,level4_huge/SNAP_web-Google.bin +Sandia_ASIC_320ks,level4_huge,321671,321671,1827807,level4_huge/Sandia_ASIC_320ks.bin +Schenk_AFE_af_shell1,level4_huge,504855,504855,17588875,level4_huge/Schenk_AFE_af_shell1.bin +Schenk_AFE_af_shell10,level4_huge,1508065,1508065,52672325,level4_huge/Schenk_AFE_af_shell10.bin +Schmid_thermal2,level4_huge,1228045,1228045,8580313,level4_huge/Schmid_thermal2.bin +Sorensen_Linux_call_graph,level4_huge,324085,324085,1208908,level4_huge/Sorensen_Linux_call_graph.bin +VLSI_test1,level4_huge,392908,392908,12968200,level4_huge/VLSI_test1.bin +Williams_webbase-1M,level4_huge,1000005,1000005,3105536,level4_huge/Williams_webbase-1M.bin +Wissgott_parabolic_fem,level4_huge,525825,525825,3674625,level4_huge/Wissgott_parabolic_fem.bin +Zaoui_kkt_power,level4_huge,2063494,2063494,14612663,level4_huge/Zaoui_kkt_power.bin +vanHeukelum_cage13,level4_huge,445315,445315,7479343,level4_huge/vanHeukelum_cage13.bin diff --git a/spgemm_excluded.txt b/spgemm_excluded.txt new file mode 100644 index 0000000000000000000000000000000000000000..1b5d8df8528ea4550b2ffa780a1d38bbc3da246a --- /dev/null +++ b/spgemm_excluded.txt @@ -0,0 +1,43 @@ +# Matrices dropped from the SpGEMM RL rollout pool (build_dataset.py --exclude-from). +# Criterion: the harness must produce a cuSPARSE baseline live on one GPU +# (benchmark_spgemm, 143 GB H200), and a cuSPARSE-backed reference kernel that +# follows the kernel contract must run. Where that fails, every rollout scores +# -1/-0.5 regardless of the policy, i.e. zero learning signal per GRPO group. +# Checked 2026-09-12 with a cuSPARSE reference kernel (C = A*A, or A*A^T for +# rectangular A via Csr2cscEx2). Error 11 = CUSPARSE_STATUS_INSUFFICIENT_RESOURCES. +# +# --- level4_huge: harness baseline itself fails (no external HSMU dump) --- +DGL_reddit # cusparse_spgemm.cu:91 err 11 (A*A does not fit) +OGB_ogbn-proteins # cusparse_spgemm.cu:91 err 11 +SNAP_wiki-Talk # cusparse_spgemm.cu:111 err 11 (power-law, A*A explodes) +SNAP_wiki-talk-temporal # cusparse_spgemm.cu:111 err 11 +# --- level4_huge: baseline only via a precomputed dump in /mnt/data2/Dr.Sparse/spgemm_ref +# (SPGEMM_EXT_REF_DIR, not on the remote); live cuSPARSE runs out of memory, +# and the GPT-5.6 teacher never produced a >=1.05x kernel on any of them --- +Belcastro_human_gene1 # C nnz 224M; ref kernel err 11 +Belcastro_mouse_gene # C nnz 483M; ref kernel err 11 +DIMACS10_asia_osm # 12M rows; ref kernel err 11 +Gupta_gupta3 # ref kernel err 11 +LAW_in-2004 # ref kernel err 11 +QY_case39 # ref kernel err 11 +# --- level3_large: harness baseline itself fails --- +LAW_cnr-2000 # cusparse_spgemm.cu:111 err 11 (web graph, A*A explodes) + +# 2026-09-17: cuSPARSE could not build the A*A reference (harness stage no_baseline) in the +# reference-plan sweep of the 498-matrix pool extension on H200. +Barabasi_NotreDame_www # level4_huge +GHS_indef_exdata_1 # level2_medium +JGD_Groebner_c8_mat11 # level2_medium +JGD_Kocay_Trec14 # level2_medium +LAW_eu-2005 # level4_huge +Mycielski_mycielskian14 # level2_medium +ND_nd6k # level2_medium +PARSEC_Ga3As3H12 # level3_large +SNAP_higgs-twitter # level4_huge +SNAP_web-NotreDame # level4_huge +Schenk_IBMNA_c-64 # level3_large +Schenk_IBMNA_c-64b # level3_large +Schenk_IBMNA_c-73 # level3_large +Schenk_IBMNA_c-73b # level3_large +TSOPF_TSOPF_FS_b39_c7 # level2_medium +Williams_cop20k_A # level3_large diff --git a/train.jsonl b/train.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..cf2d04229216b99de14de85dbf8cf8106b1e252c --- /dev/null +++ b/train.jsonl @@ -0,0 +1,607 @@ +{"messages": [{"role": "system", "content": "You are an expert CUDA programmer specializing in sparse matrix kernels for NVIDIA GPUs (B200, Blackwell, sm_100). Write compact, correct, fast kernels. Respond with exactly one ```cuda code fence containing the complete contents of kernel.cu. The code must include any necessary `#include` directives and define all required entry-point functions with the exact signatures specified. Do not call 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} diff --git a/train_list.txt b/train_list.txt new file mode 100644 index 0000000000000000000000000000000000000000..07a7431072ac82cac0db369496bc785e2e3d35c0 --- /dev/null +++ b/train_list.txt @@ -0,0 +1,607 @@ +Arenas_email +Bai_rbsb480 +Boeing_msc00726 +Boeing_nasa1824 +Boeing_nasa2910 +CPM_cz1268 +DRIVCAV_cavity05 +DRIVCAV_cavity10 +DRIVCAV_cavity14 +DRIVCAV_cavity15 +Dattorro_EternityII_A +Dattorro_EternityII_Etilde +FIDAP_ex20 +FIDAP_ex23 +FIDAP_ex24 +FIDAP_ex36 +FIDAP_ex4 +FIDAP_ex7 +Goodwin_Goodwin_010 +Grund_bayer08 +Grund_bayer09 +Grund_meg1 +Gset_G29 +Gset_G39 +Gset_G5 +Gset_G54 +HB_bcsstk12 +HB_bcsstk13 +HB_bcsstm10 +HB_bcsstm13 +HB_cegb2802 +HB_lock2232 +HB_lshp1561 +HB_mbeause +HB_orani678 +HB_psmigr_1 +HB_psmigr_2 +HB_psmigr_3 +JGD_CAG_CAG_mat1916 +JGD_CAG_CAG_mat364 +JGD_Forest_TF14 +JGD_Groebner_HFE18_96_in +JGD_Groebner_f855_mat9 +JGD_Groebner_f855_mat9_I +JGD_Groebner_robot24c1_mat5_J +JGD_Kocay_Trec13 +JGD_SL6_D_7 +JGD_SPG_EX3 +JGD_Taha_abtaha1 +JGD_Trefethen_Trefethen_2000 +JGD_Trefethen_Trefethen_700 +LeGresley_LeGresley_2508 +ML_Graph_YaleB_10NN +ML_Graph_dataset20mfeatpixel_10NN +ML_Graph_yeast_30NN +Mallya_lhr02 +MathWorks_TS +MathWorks_tomography +Meszaros_aa5 +Moqri_MISKnowledgeMap +Morandini_rotor2 +Mycielski_mycielskian11 +Mycielski_mycielskian12 +Mycielski_mycielskian9 +Negre_dendrimer +Newman_polblogs +Norris_heart2 +Norris_heart3 +Oberwolfach_piston +Oberwolfach_spiral +QCD_conf5_0-4x4-26 +SNAP_CollegeMsg +SNAP_email-Eu-core-temporal +SNAP_email-Eu-core +Sandia_adder_dcop_03 +Sandia_adder_dcop_18 +Sandia_adder_dcop_31 +Sandia_adder_dcop_37 +Sandia_adder_dcop_64 +Sandia_adder_trans_01 +TOKAMAK_utm1700b +TOKAMAK_utm3060 +TSOPF_TSOPF_RS_b300_c3 +TSOPF_TSOPF_RS_b39_c19 +TSOPF_TSOPF_RS_b39_c7 +VDOL_hangGlider_2 +VDOL_spaceShuttleEntry_4 +VDOL_spaceStation_6 +Wang_wang1 +Zitney_extr1 +Zitney_rdist3a +ACUSIM_Pres_Poisson +AG-Monien_ukerbe1 +Andrianov_ex3sta1 +Andrianov_fxm4_6 +Andrianov_net100 +Andrianov_net25 +Andrianov_net50 +Andrianov_net75 +Andrianov_pf2177 +Arenas_PGPgiantcompo +Bai_af23560 +Bai_dw4096 +Bai_mhd3200a +Bai_mhd4800a +Bai_rw5151 +Bates_Chem97Zt +Bindel_ted_A +Bindel_ted_A_unscaled +Bindel_ted_B +Bindel_ted_B_unscaled +Bodendiek_CurlCurl_0 +Boeing_bcsstk38 +Boeing_crystk01 +Boeing_crystk02 +Boeing_crystk03 +Boeing_crystm01 +Boeing_crystm02 +Boeing_nasa4704 +Boeing_pcrystk02 +Bomhof_circuit_2 +Bomhof_circuit_3 +Botonakis_FEM_3D_thermal1 +Brethour_coater2 +CPM_cz5108 +Cannizzo_sts4098 +Chen_pkustk02 +Cote_mplate +Cote_vibrobox +Cunningham_k3plates +Cylshell_s3rmq4m1 +DIMACS10_vsp_c-30_data_data +DIMACS10_vsp_data_and_seymourl +DIMACS10_wing_nodal +DNVS_trdheim +DNVS_tsyl201 +DRIVCAV_cavity17 +DRIVCAV_cavity20 +DRIVCAV_cavity21 +DRIVCAV_cavity22 +Davis_FX_March2010 +FEMLAB_poisson3Da +FIDAP_ex37 +FIDAP_ex40 +FIDAP_ex9 +Fluorem_GT01R +GHS_indef_bloweya +GHS_indef_bloweybl +GHS_indef_bratu3d +GHS_indef_linverse +GHS_indef_tuma1 +GHS_indef_tuma2 +GHS_psdef_ramage02 +GHS_psdef_wathen100 +Gaertner_big +Gleich_wb-cs-stanford +Goodwin_Goodwin_030 +Goodwin_Goodwin_040 +Goodwin_rim +Graham_graham1 +Grueninger_windtunnel_evap2d +Grund_poli3 +Gset_G56 +Gset_G58 +Gset_G60 +Gset_G61 +Gset_G63 +Gset_G64 +Gset_G66 +Guettel_TEM27623 +HB_bcsstk28 +HB_bcsstk30 +HB_gemat11 +HB_gemat12 +HB_lns_3937 +HB_lock3491 +HB_sherman3 +HB_sherman5 +Hohn_fd12 +Hohn_fd15 +Hohn_sinc15 +Hohn_sinc18 +Hollinger_g7jac100sc +IPSO_OPF_3754 +IPSO_OPF_6000 +IPSO_TSC_OPF_1047 +IPSO_TSC_OPF_300 +JGD_Forest_TF16 +JGD_Franz_Franz4 +JGD_Franz_Franz7 +JGD_G5_IG5-14 +JGD_G5_IG5-15 +JGD_G5_IG5-17 +JGD_GL7d_GL7d13 +JGD_Homology_mk12-b3 +JGD_Homology_n2c6-b6 +JGD_SPG_EX5 +JGD_Trefethen_Trefethen_20000 +JGD_Trefethen_Trefethen_20000b +LPnetlib_lp_maros_r7 +LPnetlib_lp_osa_14 +LPnetlib_lp_qap15 +Li_li +LiuWenzhuo_powersim +MKS_fp +ML_Graph_har_10NN +ML_Graph_optdigits_10NN +ML_Graph_usps_norm_5NN +Mallya_lhr04c +Mallya_lhr07 +Mallya_lhr07c +Mallya_lhr10 +Mallya_lhr11 +Mallya_lhr11c +Mallya_lhr14 +Mallya_lhr14c +Mallya_lhr17 +Mallya_lhr17c +MathWorks_Kaufhold +MathWorks_Pd +Meszaros_co9 +Meszaros_dbir1 +Meszaros_dbir2 +Meszaros_nemsemm1 +Meszaros_nsir +Meszaros_r05 +Meszaros_rat +Meszaros_scsd8-2b +Meszaros_scsd8-2c +Meszaros_scsd8-2r +Meszaros_stat96v4 +Meszaros_stat96v5 +Muite_Chebyshev3 +Mycielski_mycielskian13 +ND_nd3k +NYPA_Maragal_6 +Nasa_barth +Nasa_barth5 +Nasa_shuttle_eddy +Nemeth_nemeth01 +Nemeth_nemeth02 +Nemeth_nemeth06 +Nemeth_nemeth07 +Nemeth_nemeth09 +Nemeth_nemeth10 +Nemeth_nemeth11 +Nemeth_nemeth15 +Nemeth_nemeth17 +Nemeth_nemeth19 +Nemeth_nemeth20 +Nemeth_nemeth22 +Nemeth_nemeth24 +Nemeth_nemeth25 +Newman_as-22july06 +Newman_power +Norris_fv1 +Norris_heart1 +Oberwolfach_chipcool0 +Oberwolfach_gyro +Oberwolfach_gyro_k +Oberwolfach_t2dah_a +Oberwolfach_t2dal_a +Oberwolfach_t3dl +Oberwolfach_t3dl_a +Oberwolfach_t3dl_e +Okunbor_aft01 +PARSEC_Na5 +PARSEC_Si10H16 +PARSEC_Si5H12 +PARSEC_SiH4 +PARSEC_benzene +POLYFLOW_invextr1_new +POLYFLOW_mixtank_new +Pajek_EAT_RS +Pajek_Erdos02 +Pajek_Erdos972 +Pajek_Erdos982 +Pajek_Erdos992 +Pajek_FA +Pajek_Kohonen +Pajek_Lederberg +Pajek_Reuters911 +Pajek_Zewail +Pajek_foldoc +Pajek_geom +Pothen_barth +Pothen_barth5 +Pothen_bodyy4 +Pothen_bodyy6 +Pothen_tandem_vtx +Puri_ABACUS_shell_ud +QY_case9 +Rommes_bips98_1450 +SNAP_Oregon-1 +SNAP_Oregon-2 +SNAP_as-caida +SNAP_ca-AstroPh +SNAP_ca-HepPh +SNAP_p2p-Gnutella04 +SNAP_p2p-Gnutella05 +SNAP_p2p-Gnutella06 +SNAP_p2p-Gnutella08 +SNAP_p2p-Gnutella09 +SNAP_p2p-Gnutella24 +SNAP_soc-sign-bitcoin-alpha +SNAP_soc-sign-bitcoin-otc +SNAP_sx-mathoverflow +SNAP_wiki-RfA +Schenk_IBMNA_c-30 +Schenk_IBMNA_c-31 +Schenk_IBMNA_c-33 +Schenk_IBMNA_c-40 +Schenk_IBMNA_c-41 +Schenk_IBMNA_c-43 +Schenk_IBMNA_c-45 +Schenk_IBMNA_c-47 +Schenk_IBMNA_c-49 +Schenk_IBMNA_c-50 +Schenk_IBMNA_c-51 +Schenk_IBMNA_c-53 +Schenk_IBMSDS_2D_27628_bjtcai +Schenk_ISEI_igbt3 +Schulthess_N_reactome +Shen_e40r0100 +Shen_shermanACd +Simon_olafu +Simon_raefsky1 +Simon_raefsky2 +Simon_raefsky3 +Simon_raefsky6 +TAMU_SmartGridCenter_ACTIVSg2000 +TKK_t2d_q4 +TKK_tube1 +TKK_tube2 +TOKAMAK_utm5940 +TSOPF_TSOPF_FS_b162_c1 +TSOPF_TSOPF_RS_b162_c1 +TSOPF_TSOPF_RS_b162_c3 +TSOPF_TSOPF_RS_b162_c4 +TSOPF_TSOPF_RS_b2052_c1 +TSOPF_TSOPF_RS_b300_c1 +TSOPF_TSOPF_RS_b300_c2 +VDOL_dynamicSoaringProblem_7 +VDOL_freeFlyingRobot_11 +VDOL_hangGlider_5 +VDOL_kineticBatchReactor_6 +VDOL_lowThrust_11 +VDOL_lowThrust_4 +VanVelzen_Zd_Jac2 +VanVelzen_Zd_Jac2_db +VanVelzen_Zd_Jac3 +VanVelzen_Zd_Jac3_db +VanVelzen_Zd_Jac6 +VanVelzen_Zd_Jac6_db +VanVelzen_std1_Jac2 +VanVelzen_std1_Jac2_db +VanVelzen_std1_Jac3_db +Wang_swang1 +Wang_swang2 +Zitney_hydr1c +Zitney_rdist1 +Zitney_rdist2 +vanHeukelum_cage10 +vanHeukelum_cage9 +AG-Monien_bfly +AG-Monien_brack2 +AG-Monien_ccc +ATandT_onetone1 +ATandT_onetone2 +Andrianov_net125 +Andrianov_net4-1 +Averous_epb3 +Barabasi_NotreDame_actors +Bomhof_circuit_4 +Botonakis_FEM_3D_thermal2 +Botonakis_thermomech_TC +Botonakis_thermomech_dK +Bova_rma10 +Bydder_mri1 +Castrillon_denormal +Chen_pkustk06 +Chen_pkustk09 +Chen_pkustk10 +Chen_pkustk11 +Clark_tomographic1 +Cunningham_qa8fk +DIMACS10_G_n_pin_pout +DIMACS10_al2010 +DIMACS10_caidaRouterLevel +DIMACS10_coAuthorsCiteseer +DIMACS10_fe_body +DIMACS10_fe_rotor +DIMACS10_fe_tooth +DIMACS10_ia2010 +DIMACS10_luxembourg_osm +DIMACS10_md2010 +DIMACS10_nd2010 +DIMACS10_preferentialAttachment +DIMACS10_rgg_n_2_15_s0 +DIMACS10_rgg_n_2_16_s0 +DIMACS10_rgg_n_2_17_s0 +DIMACS10_rgg_n_2_18_s0 +DIMACS10_smallworld +DIMACS10_vsp_bcsstk30_500sep_10in_1Kout +DIMACS10_vsp_sctap1-2b_and_seymourl +DIMACS10_vsp_vibrobox_scagr7-2c_rlfddd +DNVS_ship_001 +DNVS_ship_003 +Dattorro_EternityII_E +Embree_ifiss_mat +FlowIPM22_uni_chimera_i3 +FlowIPM22_uni_chimera_i4 +FlowIPM22_uni_chimera_i5 +Fluorem_PR02R +GHS_indef_a0nsdsil +GHS_indef_aug3dcqp +GHS_indef_bmw3_2 +GHS_indef_c-58 +GHS_indef_c-63 +GHS_indef_c-68 +GHS_indef_c-70 +GHS_indef_c-72 +GHS_indef_dawson5 +GHS_indef_ncvxqp7 +GHS_indef_stokes128 +GHS_psdef_bmw7st_1 +GHS_psdef_copter2 +GHS_psdef_oilpan +GHS_psdef_pwt +GHS_psdef_torsion1 +GHS_psdef_wathen120 +Gleich_usroads-48 +Gleich_usroads +Goodwin_Goodwin_054 +Goodwin_Goodwin_071 +Goodwin_Goodwin_127 +Grund_bayer01 +Grund_poli4 +Guettel_TEM152078 +Guettel_TEM181302 +Hamm_bcircuit +Hollinger_g7jac140sc +Hollinger_g7jac160sc +Hollinger_mark3jac100 +Hollinger_mark3jac120sc +Hollinger_mark3jac140 +IPSO_HTC_336_9129 +IPSO_OPF_10000 +JGD_GL7d_GL7d23 +JGD_GL7d_GL7d24 +JGD_Homology_n4c6-b10 +JGD_Homology_n4c6-b12 +JGD_Homology_n4c6-b5 +JGD_Homology_n4c6-b6 +JGD_Homology_n4c6-b9 +JGD_Homology_shar_te2-b2 +JGD_Homology_shar_te2-b3 +Kamvar_Stanford +Kim_kim1 +LAW_enron +ML_Graph_k49_norm_10NN +Mallya_lhr34 +Mallya_lhr34c +Mallya_lhr71 +Mallya_lhr71c +Mancktelow_viscorocks +MaxPlanck_shallow_water1 +McRae_ecology1 +Meszaros_fxm3_16 +Meszaros_fxm4_6 +Meszaros_karted +Meszaros_pltexpa +Meszaros_rlfprim +Meszaros_stat96v3 +Mittelmann_fome12 +Mittelmann_watson_1 +Muite_Chebyshev4 +Mulvey_pfinan512 +NYPA_Maragal_7 +NYPA_Maragal_8 +Nasa_pwt +Newman_cond-mat-2005 +Norris_lung2 +Norris_torso3 +Oberwolfach_boneS01 +Oberwolfach_gas_sensor +Oberwolfach_rail_79841 +Oberwolfach_t3dh +Oberwolfach_t3dh_a +PARSEC_CO +PARSEC_Ga10As10H30 +PARSEC_Ga19As19H42 +PARSEC_Ge99H100 +PARSEC_H2O +PARSEC_Si34H36 +PARSEC_SiO +Pothen_pwt +Pothen_tandem_dual +PowerSystem_power197k +Qaplib_lp_nug30 +Quaglino_viscoplastic2 +Rajat_rajat15 +Rajat_rajat20 +Rajat_rajat23 +Raju_laminar_duct3D +Rommes_bauru5727 +Rommes_juba40k +Rothberg_3dtube +Rothberg_cfd1 +Rothberg_gearbox +SNAP_email-Enron +SNAP_loc-Brightkite +SNAP_loc-Gowalla +SNAP_p2p-Gnutella31 +SNAP_soc-Epinions1 +SNAP_soc-Slashdot0811 +SNAP_soc-Slashdot0902 +SNAP_soc-sign-Slashdot081106 +SNAP_soc-sign-Slashdot090216 +SNAP_soc-sign-Slashdot090221 +SNAP_soc-sign-epinions +SNAP_sx-superuser +Sanghavi_ecl32 +Schenk_IBMNA_c-57 +Schenk_IBMNA_c-60 +Schenk_IBMNA_c-61 +Schenk_IBMNA_c-62 +Schenk_IBMNA_c-66 +Schenk_IBMNA_c-66b +Schenk_IBMNA_c-67 +Schenk_IBMNA_c-67b +Schenk_IBMSDS_2D_54019_highK +Schenk_IBMSDS_matrix-new_3 +Schenk_ISEI_barrier2-9 +Schenk_ISEI_ohne2 +Schenk_ISEI_para-10 +Schenk_ISEI_para-4 +Schenk_ISEI_para-9 +Schmid_thermal1 +Simon_bbmat +Simon_venkat25 +TKK_engine +TSOPF_TSOPF_RS_b2383 +TSOPF_TSOPF_RS_b39_c30 +TSOPF_TSOPF_RS_b678_c2 +Toledo_deltaX +UTEP_Dubcova2 +UTEP_Dubcova3 +Um_offshore +VLSI_nv1 +VLSI_power9 +VLSI_radiation +VLSI_ss1 +Vavasis_av41092 +Williams_cant +Williams_consph +Williams_mac_econ_fwd500 +Williams_pdb1HYS +Yoshiyasu_image_interp +Zhao_Zhao1 +vanHeukelum_cage11 +vanHeukelum_cage12 +AG-Monien_debr +ANSYS_Delor338K +ANSYS_Delor64K +ATandT_pre2 +Bourchtein_atmosmodd +CEMW_tmt_unsym +DIMACS10_NACA0015 +DIMACS10_auto +DIMACS10_delaunay_n24 +DIMACS10_ny2010 +FlowIPM22_Spielman_k100 +Freescale_Freescale1 +Freescale_circuit5M_dc +Freescale_memchip +GHS_indef_helm2d03 +GHS_indef_mario002 +Hamrle_Hamrle3 +Hardesty_Hardesty1 +JGD_Margulies_kneser_10_4_1 +Janna_CoupCons3D +Kamvar_Stanford_Berkeley +LAW_dblp-2010 +Martin_marine1 +McRae_ecology2 +Meszaros_degme +Pajek_IMDB +SNAP_amazon0312 +SNAP_amazon0505 +SNAP_amazon0601 +SNAP_com-Amazon +SNAP_roadNet-CA +SNAP_roadNet-PA +SNAP_roadNet-TX +SNAP_web-BerkStan +SNAP_web-Google +Sandia_ASIC_320ks +Schenk_AFE_af_shell1 +Schenk_AFE_af_shell10 +Schmid_thermal2 +Sorensen_Linux_call_graph +VLSI_test1 +Williams_webbase-1M +Wissgott_parabolic_fem +Zaoui_kkt_power +vanHeukelum_cage13