SparseDitto: Customizing GPU Kernels for Different Sparsity Patterns with LLM-Based Agentic System

Caiwen Ding; Guangyan Sun; Jinwei Tang; Mingyi Hong; Shiyang Li; Yanzhi Wang

REVIEW 3 major objections 6 minor 40 references

SparseDitto: Customizing GPU Kernels for Different Sparsity Patterns with LLM-Based Agentic System

T0 review · 3 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read An LLM agent that builds a fresh GPU kernel for each sparse matrix, operator, and target GPU outperforms the vendor sparse library by a geometric mean of 2.68x to 2.79x, with wins up to 146x.

desk verdict SparseDitto's headline speedups are plausible and the evaluation is careful, but missing success-rate and run-to-run variance data make the numbers conditional on the LLM drawing a favorable sample. read the letter →

arxiv 2608.05033 v1 pith:TSRRSXY2 submitted 2026-08-05 cs.DC cs.LG

Shiyang Li , Guangyan Sun , Jinwei Tang , Yanzhi Wang , Mingyi Hong , Caiwen Ding This is my paper

classification cs.DCcs.LG

keywords sparsematrixcomputationGPUkernelskernelgenerationlargelanguagemodelsSpMVMMGEMMsparsitypatterns

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

SparseDitto claims that no fixed GPU sparse kernel can stay fast across sparsity patterns, operators, and GPU generations, and that a system which builds a fresh kernel for each matrix, operator, and target GPU can do better. It combines structural analysis of the input matrix with a small interpretable ranking model and an LLM-based agentic loop that writes CUDA kernels, checks them numerically, and profiles them on the target hardware. Across 350 tasks spanning three sparse operations, the system reaches a geometric-mean speedup of 2.68x over the vendor sparse library on one GPU and 2.79x on another, with a maximum of 146.61x. This matters because a mismatched sparse representation can cost orders of magnitude: for a single matrix the vendor library itself spans a 350x gap between two of its formats, so adapting the kernel to the pattern is a practical route to speedups that fixed libraries and specialized systems leave on the table.

What carries the argument

The load-bearing mechanism is an iterative measurement loop wrapped around a structured design space. Each candidate is a configuration tuple \(\Pi=\langle R,S,\theta_H\rangle\): representation \(R=\langle L,I\rangle\) (value layout plus sparse metadata), schedule \(S=\langle P,D\rangle\) (parallel decomposition plus dataflow), and hardware mapping \(\theta_H\) (tile sizes, launch geometry, shared-memory usage). Before code generation, a 36-feature structural profile feeds an additive energy model that ranks established strategies, so the search starts near designs that already work for matrices like the current one; after code generation, numerical validation and GPU profiling feed back into the planner, so the target hardware's measurements, not the model's confidence, decide what is kept. This combination is what lets the system both reuse prior knowledge and invent unlabeled strategies.

What would settle it

Run the identical pipeline on the same 350-task suite with a different capable code-generation model under the same search budget; if the geometric-mean speedup over the vendor library falls close to 1x, the reported gains are attributable to the specific model's coding ability rather than to the structural analysis and measurement loop.

Watch

Extended reading notes

Core claim

The paper's central claim is that sparse-kernel construction should be treated as a joint design problem over representation, execution schedule, and hardware mapping, and that this space is best searched with measurement-driven LLM agents rather than fixed libraries or hand-written rules. Each candidate is a configuration tuple \(\Pi=\langle R,S,\theta_H\rangle\), where \(R\) bundles the data layout and sparse metadata, \(S\) bundles the parallel decomposition and dataflow, and \(\theta_H\) carries hardware-specific parameters such as tile size and launch geometry. A structural profiler computes 36 features, an additive energy model ranks known strategies from an offline measurement corpus, and a planner seeds several branches that a coding agent implements and a verification agent measures on the target GPU. The reported results support the claim: the generated kernels beat the vendor library in 94% of evaluated tasks, and the largest wins come from kernels that no predefined strategy label describes, which suggests the search escapes its own prior.

Load-bearing premise

The whole pipeline depends on the language model succeeding at writing and fixing correct CUDA kernels on most tasks within the fixed search budget; if the model fails too often, no amount of planning and profiling can produce the reported speedups.

Editorial extensions

If this is right

If a user runs many sparse workloads on one GPU, the per-matrix kernels beat the vendor library in 94% of evaluated cases, so choosing the kernel itself, not just the library, is where the speedup is.
On a different GPU generation the pipeline regenerates kernels from scratch and retains essentially the same aggregate speedup, so the approach transfers without hand-tuning to new hardware.
Because 36% of the winning kernels implement strategies outside the ranking model's vocabulary and those wins carry higher speedups, the search does not merely pick among known formats.
Replacing sparse aggregation kernels with generated ones improves end-to-end GCN training time by up to 3.39x, so the gains survive the surrounding training loop and are not confined to isolated microbenchmarks.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The same design could be pointed at other sparse operations such as triangular solves or sparse tensor contractions, since the planner already consumes device property tables and the verification loop is measurement-based rather than format-specific.
The 36% of wins outside the predefined vocabulary suggests the ranking model is a warm start rather than an upper bound; a planner that learns to mutate strategy families from structural features might find still more unlabeled winners.
The headline speedups should be read as a property of the current code-generation model under the fixed search budget: a weaker model would reduce the number of valid candidates and would likely shift which matrices lose, so reproducibility depends on model capability, not just on the planning and profiling machinery.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Colleague,

Here's the short version: this is a real systems paper with an unusually careful evaluation, but the headline 2.7x speedup is measured over tasks that produced a valid kernel, and the paper never says how many tasks failed. That gap needs closing before I'd trust the number.

What's actually new: SparseDitto is the first LLM-based kernel generator I've seen that covers SpMV, SpMM, and SpGEMM under one framework, with structural features guiding an additive energy model that ranks known strategies, a hierarchical planner that seeds candidate designs, and coding/verification agents that iterate on the target GPU. The 36-feature profiler and the energy model's interpretability are nice pieces. The analysis of the 36% of winning kernels that fall outside the selector vocabulary is worth attention—it shows the search goes beyond its prior, and those out-of-vocabulary wins carry higher speedups.

The evaluation deserves credit: fastest cuSPARSE config per task, predeclared tolerance-based validation, bootstrap confidence intervals, an ablation, and NCU cache/bandwidth analysis. The comparisons with CB-SpMV, DTC-SpMM, SparseTIR, and HSMU-SpGEMM are the right ones.

Soft spots, in proportion. The biggest is the stress-test concern: one run per task, no success rate, no seeds, proprietary LLM. The bootstrap interval resamples tasks, not generation runs, so it says nothing about LLM variance. If even 5% of tasks fail to produce a valid kernel, the geometric mean over successes overstates what a user should expect. This is fixable—report per-task success, maybe a second run with a different seed, and what the fallback is when no branch yields a valid kernel. Also, the energy model is trained on one GPU and applied to another without retraining; the H200 results being nearly identical could be luck or could mean the ranking generalizes—worth a sentence. Minor: SpGEMM only covers A*A and A*A^T, and the K=128 GCN result is a 1% effect.

I'd send this to peer review. The system is substantial, the claims are important if true, and the missing reproducibility data is addressable in revision. Anyone working on LLM-based kernel generation or sparse auto-tuning should read it, but they should treat the speedup as conditional pending the success-rate data.

Referee Report

3 major / 6 minor

Summary. This paper presents SparseDitto, an LLM-based agentic system that produces a custom CUDA kernel for a given sparse matrix, operator, and target GPU. The system computes 36 structural features, uses an additive energy model trained on an offline corpus to rank known strategies, and then runs a hierarchical planner, coding agent, and verification agent that compile, numerically validate, and profile candidate kernels on the target GPU. The evaluation covers 60 SuiteSparse matrices across SpMV, SpMM at four widths, and SpGEMM on an RTX PRO 6000 and an H200, reporting geometric-mean speedups of 2.68x and 2.79x over the fastest applicable cuSPARSE configuration, with a maximum of 146.61x, and an end-to-end GCN training speedup of up to 3.39x.

Significance. If the reported results are representative, SparseDitto would be a significant advance: it is the first system in the paper's scope to unify SpMV, SpMM, and SpGEMM under one adaptive framework, and it appears to beat both cuSPARSE and several recent specialized systems on the evaluated workloads. The evaluation is in many ways careful: the baseline is the fastest valid cuSPARSE configuration per task, the tolerance-based validation rule is predeclared and uniformly applied, bootstrap confidence intervals are reported, the training and test matrix sets are disjoint, and an ablation separates the contributions of pattern analysis and architecture-aware planning. The main weakness is stochasticity: because each task is generated by a nondeterministic LLM pipeline with no reported success rate or multi-run variance, the headline numbers may be conditional on successful draws.

major comments (3)

[§3.4 and §4.1] The headline geometric-mean speedups rest entirely on the stochastic agentic pipeline, but the paper reports exactly one generation run per task and never states how many tasks produced no numerically valid kernel within the fixed budget (three branches, up to five generate-compile-benchmark iterations, then five more for the two fastest branches). Section 4.1 only reports speedups 'over the validated tasks.' If any task fails all branches, the mean is conditional on success and overstates the expected speedup for a fresh input; the problem is sharpest for the 127 outside-vocabulary tasks in Table 3, where a single lucky branch can dominate (e.g., the 146.61x maximum). The 95% bootstrap intervals resample tasks, not generation runs, so they do not address run-to-run variance. The paper should report the per-operator success rate, the distribution of attempts and failures, what happens when all branches fail, and a multi-seed repeat of a representative subset with a confidence interval over generation runs.
[§4.1 and Table 3] The reported task count is internally inconsistent. Section 4.1 describes 60 matrices with SpMV, four SpMM widths, and SpGEMM, i.e., 360 tasks, and says only that seven large SpGEMM tasks were excluded because cuSPARSE ran out of resources; that would leave 353 tasks, yet Table 3 and the text report exactly 350 tasks (60 SpMV + 238 SpMM + 52 SpGEMM). The manuscript does not explain the missing three SpMM/SpGEMM tasks. In addition, excluding tasks where the baseline cannot run removes exactly the largest and hardest cases and therefore biases the aggregate and the SpGEMM speedup upward relative to a user who still needs those products; those tasks should be reported separately, ideally with an alternative reference or with SparseDitto's absolute performance.
[§4.5] Table 3 shows that tasks whose winning kernel is outside the selector vocabulary have higher mean speedup than inside-vocabulary tasks, and the paper presents this as evidence that the search is not confined to its prior. Because the final strategy is selected after measuring candidates, this comparison is outcome-dependent: the outside-vocabulary set consists of branches that won, so a higher mean is expected even if exploration contributed nothing on average. A fairer test would compare, per task, the best inside-vocabulary candidate against the best outside-vocabulary candidate under identical budgets, or report the success rate of outside-vocabulary branches. As written, the claim in Section 1 that 'those cases carry a higher mean speedup' overstates what Table 3 establishes.

minor comments (6)

[Throughout] The paper repeatedly references 'supplementary material' (e.g., Section 3.3 and Section 4.4), but the arXiv submission contains no supplementary file and no code or data availability statement; without the generated kernels, prompts, and measurement scripts, the results cannot be reproduced or audited.
[§3.2, Eq. (9)] The energy objective depends on hyperparameters such as the operator weights lambda_o, the softmax temperature T, and the basis dimensions, but the manuscript reports none of their values and no sensitivity study; please add them.
[§4.3] The 'Task only' ablation condition is described only as receiving the task description; specify exactly what the planner and coder receive in that condition so that the ablation is interpretable.
[Reference [4]] The title of the CB-SpMV reference contains a duplicated 'for for'; please fix the typo.
[Table 1] The table would be easier to read if the ratio columns were explicitly labeled 'ours/theirs' and if the Delta-L1 and Delta-L2 columns were identified as percentage points; also define 'L1 req.' in the caption.
[§4.1] The paper notes that the aggregate confidence intervals on the two GPUs overlap, but the per-operator intervals are only shown graphically; please report the numeric intervals for each operator and width.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation: SparseDitto's reported kernels are chosen by target-GPU benchmarking and validation, not by the learned selector or by any self-cited result.

full rationale

Walking the derivation chain: structural features (Section 3.1) feed an additive energy model (Section 3.2) that ranks candidate strategies, but the paper explicitly states that the learned ranking is not the final output: "The selector returns a ranked set of strategies rather than a final implementation. The learned ranking therefore guides the known part of the design space, while target-GPU search determines the final implementation" (Section 3.2). Candidate kernels are planned in Section 3.3, then generated, compiled, numerically validated, and benchmarked: "SparseDitto returns the fastest numerically valid candidate across all branches" (Section 3.4). The reported geometric-mean speedups in Section 4.1 are therefore empirical measurements of kernels selected by measurement, not values predicted by the fitted model. The selector is evaluated separately for ranking quality in Section 4.4, and its training set does not overlap the main test set: "There is no overlap between this training set and our test set for main results in Section 4.1." Baselines are external systems (cuSPARSE, CB-SpMV, DTC-SpMM, SparseTIR, HSMU-SpGEMM) measured under the same protocol. The only self-citation (StitchCUDA, reference [17]) appears in the related-work discussion of LLM-based systems and is not load-bearing; no uniqueness claim or prior result from the authors is used to justify the measured speedups. The skeptical reader's missing-success-rate and run-to-run variance concern is a reproducibility and statistical-reporting risk, not a circularity: even if a single unseeded draw were lucky, the headline number remains an empirical measurement rather than a quantity forced by the paper's own equations or by a self-citation. No step in the paper reduces to its inputs by construction, so the appropriate finding is no significant circularity.

Assumptions & free parameters 6 free parameters · 5 assumptions · 0 invented entities

The system's performance depends on the hand-designed feature set, the corpus-trained energy model, and several hand-chosen candidate sets and thresholds. These are disclosed in the paper but are not derived from first principles.

free parameters (6)

Energy model parameters (w1, b1, w2, beta_o_s) = trained on 400-matrix offline corpus
Equations 7-9; all strategy-ranking weights are fit to measured runtimes on a separate corpus.
SELL slice heights c = {16, 32, 512}
Section 3.1; candidate slice heights for SELL layout, chosen by hand from prior work.
BSR block sizes b = {4, 8, 16}
Section 3.1; candidate block sizes for BSR, hand-selected.
Accumulator capacity thresholds h = 512, 4K, 32K
Equation 5; thresholds chosen from corpus measurements in Section 3.1.
Search budget = 3 branches x 5 iterations + 5 on 2 fastest
Section 4; fixed number of generate-compile-benchmark rounds per task.
Loss hyperparameters lambda_o = not reported exactly
Equation 9; operator-specific weights, stated qualitatively (small for SpMV, larger for SpMM and SpGEMM).

assumptions (5)

domain assumption The 36 structural features are sufficient to rank sparse-kernel strategies across operators and GPUs.
Section 3.1; the energy model's ranking quality depends on this vocabulary.
domain assumption The 400-matrix offline corpus is representative enough that the trained selector generalizes to the 60-matrix test set.
Section 4.4; no overlap claim, but generalization is assumed.
domain assumption GPT-5.6-terra can generate correct CUDA kernels from the planner's specifications within the fixed budget.
Sections 3.4 and 4; the whole pipeline depends on LLM code generation.
domain assumption cuSPARSE FP32 results are a valid correctness reference for sparse kernel outputs.
Section 4; validation rule uses cuSPARSE as ground truth.
ad hoc to paper The heuristic feedback rules in the verification agent (e.g., switching representation when padding is excessive) are sufficient to guide refinement.
Section 3.4; thresholds for 'excessive' are not quantified.

how reviews work

0 comments

Cite this review

Pith. "Pith review of SparseDitto: Customizing GPU Kernels for Different Sparsity Patterns with LLM-Based Agentic System." pith.science (2026). https://pith.science/paper/TSRRSXY2

@misc{pith2026260805033,
  author       = {Pith},
  title        = {Pith review of: SparseDitto: Customizing GPU Kernels for Different Sparsity Patterns with LLM-Based Agentic System},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/TSRRSXY2}},
  note         = {Machine review of arXiv:2608.05033}
}

read the original abstract

Sparse matrix kernels are fundamental to scientific computing, graph analytics, and machine learning. Their GPU performance depends strongly on the input sparsity pattern and execution strategy. For the same SpMM on the same matrix, cuSPARSE exhibits a 350x performance gap between CSR and Blocked-ELL. Our study of multiple data formats, specialized systems, and sparse compilers shows that no single implementation consistently dominates across sparsity patterns and operators. This motivates a system that can adapt its representation, execution strategy, and hardware mapping to each workload and target GPU. We present SparseDitto, an LLM-based system that constructs a GPU kernel for each matrix, operator, and target GPU. SparseDitto supports SpMV, SpMM, and SpGEMM within a unified design framework. A lightweight additive model ranks established strategies using structural features of the input matrix. An architecture-aware planner then proposes several candidate designs. Coding and verification agents implement and refine them using measurements from the target GPU. Across three sparse operators and a diverse set of matrices, SparseDitto achieves a geometric-mean speedup of 2.68x over cuSPARSE on an NVIDIA RTX PRO 6000 GPU, with a maximum of 146.61x. On an NVIDIA H200 GPU, it achieves 2.79x, with a maximum of 78.5x. Its generated SpMM kernels also accelerate full-batch GCN training by up to 3.39x.

Figures

Figures reproduced from arXiv: 2608.05033 by the authors.

**Figure 1.** One 16 × 16 matrix exposes intrinsic pattern cues and format-induced costs. The matrix contains an irregular dense tile, a high-degree column, an empty row, and uneven row lengths. CSR and CSC traverse compressed rows and columns, respectively. SELL-C with 𝐶 = 8 introduces slice-local padding, while 4 × 4 BSR introduces block fill. The right column shows the resulting work granularity and imbalance for rows, columns… view at source ↗

**Figure 2.** Sparse kernel performance sensitivity on ten SuiteSparse matrices [ [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗

**Figure 3.** SparseDitto constructs and refines sparse GPU implementations. Structural features and an additive energy model [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗

Figures from the paper (5 more)

**Figure 4.** Figure 4: Hierarchical architecture-aware planning in [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]

**Figure 5.** Figure 5: Generated kernel performance for SpMV, SpMM, [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]

**Figure 6.** Figure 6: The same measurement on the H200. Both panels [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]

**Figure 7.** Figure 7: Structural feature importance per operator. Each [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]

**Figure 8.** Figure 8: Full-batch GCN epoch time on Reddit across hidden [PITH_FULL_IMAGE:figures/full_fig_p011_8.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

40 extracted references · 23 canonical work pages

[1]

Rishabh Agarwal, Levi Melnick, Nicholas Frosst, Xuezhou Zhang, Ben Lengerich, Rich Caruana, and Geoffrey E. Hinton. 2021. Neural additive models: Interpretable machine learning with neural nets. InAdvances in Neural Information Processing Systems (NeurIPS), Vol. 34. 4699–4711

work page 2021
[2]

Chris Burges, Tal Shaked, Erin Renshaw, Ari Lazier, Matt Deeds, Nicole Hamilton, and Greg Hullender. 2005. Learning to rank using gradient descent. InProc. 22nd Int. Conf. on Machine Learning (ICML). 89–96

work page 2005
[3]

Zhe Cao, Tao Qin, Tie-Yan Liu, Ming-Feng Tsai, and Hang Li. 2007. Learning to rank: from pairwise approach to listwise approach. InProc. 24th Int. Conf. on Machine Learning (ICML). 129–136

work page 2007
[4]

Xing Cong, FuKai Sun, YiFan Chen, Chenhao Xie, Yi Liu, and Depei Qian. 2025. CB-SpMV: A Data Aggregating and Balance Algorithm for for Cache-Friendly Block-Based SpMV on GPUs. InProceedings of the 39th ACM International Con- ference on Supercomputing. 149–160

work page 2025
[5]

Davis and Yifan Hu

Timothy A. Davis and Yifan Hu. 2011. The University of Florida Sparse Matrix Collection.ACM Trans. Math. Software38, 1 (2011), 1:1–1:25

work page 2011
[6]

Zhen Du, Jiajia Li, Yinshan Wang, Xueqi Li, Guangming Tan, and Ninghui Sun
[7]

Ruibo Fan, Wei Wang, and Xiaowen Chu. 2024. DTC-SpMM: Bridging the Gap in Accelerating General Sparse Matrix Multiplication with Tensor Cores. InPro- ceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 3(La Jolla, CA, USA)(AS- PLOS ’24). Association for Computing Machinery, New...

arXiv 2024
[8]

Salvatore Filippone, Valeria Cardellini, Davide Barbieri, and Alessandro Fanfarillo

Show all 40 references

[9]

Friedman

Jerome H. Friedman. 2001. Greedy function approximation: a gradient boosting machine.Annals of Statistics29, 5 (2001), 1189–1232

2001
[10]

Hamilton, Rex Ying, and Jure Leskovec

William L. Hamilton, Rex Ying, and Jure Leskovec. 2017. Inductive representation learning on large graphs. InProceedings of the 31st International Conference on Neural Information Processing Systems(Long Beach, California, USA)(NIPS’17). Curran Associates Inc., Red Hook, NY, U...

2017
[11]

Pawan Harish and P. J. Narayanan. 2007. Accelerating Large Graph Algorithms on the GPU Using CUDA. InProceedings of the 14th International Conference on High Performance Computing(Goa, India)(HiPC’07). Springer-Verlag, Berlin, Heidelberg, 197–208

2007
[12]

Hastie and Robert J

Trevor J. Hastie and Robert J. Tibshirani. 1990.Generalized Additive Models. Chapman & Hall/CRC

1990
[13]

Abdullah Al Raqibul Islam, Helen Xu, Dong Dai, and Aydın Buluç. 2025. Im- proving SpGEMM Performance Through Matrix Reordering and Cluster-wise Computation.arXiv preprint arXiv:2507.21253(2025)

2025 arXiv
[14]

Fredrik Kjolstad, Shoaib Kamil, Stephen Chou, David Lugato, and Saman Amaras- inghe. 2017. The tensor algebra compiler.Proc. ACM Program. Lang.1, OOPSLA, Article 77 (Oct. 2017), 29 pages. doi:10.1145/3133901

2017 doi
[15]

Moritz Kreutzer, Georg Hager, Gerhard Wellein, Holger Fehske, and Alan R. Bishop. 2014. A Unified Sparse Matrix Data Format for Efficient General Sparse Matrix-Vector Multiplication on Modern Processors with Wide SIMD Units. 36, 5 (Jan. 2014), C401–C423. doi:10.1137/130930352

2014 doi
[16]

Yann LeCun, Sumit Chopra, Raia Hadsell, Marc’Aurelio Ranzato, and Fu Jie Huang
[17]

Shiyang Li, Zijian Zhang, Winson Chen, Yuebo Luo, Mingyi Hong, and Caiwen Ding. 2026. StitchCUDA: An Automated Multi-Agents End-to-End GPU Pro- gramming Framework with Rubric-based Agentic Reinforcement Learning. In Proceedings of the 43rd International Conference on Machine L...

2026
[18]

Weifeng Liu and Brian Vinter. 2015. CSR5: An Efficient Storage Format for Cross- Platform Sparse Matrix-Vector Multiplication. InProceedings of the 29th ACM on International Conference on Supercomputing(Newport Beach, California, USA) (ICS ’15). Association for Computing Machi...

2015
[19]

Duane Merrill and Michael Garland. 2016. Merge-Based Parallel Sparse Matrix- Vector Multiplication. InSC ’16: Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis. 678–689. doi:10. 1109/SC.2016.57

2016
[20]

Yusuke Nagasaka, Akira Nukada, and Satoshi Matsuoka. 2017. High-Performance and Memory-Saving Sparse General Matrix-Matrix Multiplication for NVIDIA Pascal GPU. In2017 46th International Conference on Parallel Processing (ICPP). 101–110. doi:10.1109/ICPP.2017.19

2017 doi
[21]

Yuyao Niu, Zhengyang Lu, Haonan Ji, Shuhui Song, Zhou Jin, and Weifeng Liu
[22]

NVIDIA Corporation. 2026. cuSPARSE Library Documentation. https://docs. nvidia.com/cuda/cusparse/

2026
[23]

OpenAI. 2026. GPT-5.6: Frontier Intelligence That Scales with Your Ambition. Accessed: 2026-07-31. https://openai.com/index/gpt-5-6/

2026
[24]

Zhang, William Hu, Christopher Ré, and Azalia Mirhoseini

Anne Ouyang, Simon Guo, Simran Arora, Alex L. Zhang, William Hu, Christopher Ré, and Azalia Mirhoseini. 2025. KernelBench: Can LLMs Write Efficient GPU Kernels? arXiv:2502.10517 [cs.LG] https://arxiv.org/abs/2502.10517

2025 arXiv
[25]

InProceedings of the 27th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming(Seoul, Republic of Korea) 11 Anonymous Submission, 2026, Li et al

TileSpGEMM: a tiled algorithm for parallel sparse general matrix-matrix multiplication on GPUs. InProceedings of the 27th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming(Seoul, Republic of Korea) 11 Anonymous Submission, 2026, Li et al. (PPoPP ’22). As...

2026
[26]

Hongwu Peng, Xi Xie, Kaustubh Shivdikar, Md Amit Hasan, Jiahui Zhao, Shaoyi Huang, Omer Khan, David Kaeli, and Caiwen Ding. 2024. MaxK-GNN: Extremely Fast GPU Kernel Design for Accelerating Graph Neural Networks Training. In Proceedings of the 29th ACM International Conference...

2024
[27]

Sadayappan

Naser Sedaghati, Te Mu, Louis-Noël Pouchet, Srinivasan Parthasarathy, and P. Sadayappan. 2015. Automatic selection of sparse matrix representation on GPUs. InProc. 29th ACM Int. Conf. on Supercomputing (ICS)

2015
[28]

Linghao Song, Yuze Chi, Atefeh Sohrabizadeh, Young-kyu Choi, Jason Lau, and Jason Cong. 2022. Sextans: A Streaming Accelerator for General-Purpose Sparse- Matrix Dense-Matrix Multiplication. InProceedings of the 2022 ACM/SIGDA In- ternational Symposium on Field-Programmable Ga...

2022
[29]

Mathias Parger, Martin Winter, Daniel Mlakar, and Markus Steinberger. 2020. spECK: accelerating GPU sparse matrix-matrix multiplication through light- weight analysis(PPoPP ’20). Association for Computing Machinery, New York, NY, USA, 362–375. doi:10.1145/3332466.3374521

2020
[30]

Vázquez, E.M

F. Vázquez, E.M. Garzón, and J.J. Fernández. 2010. A matrix approach to tomo- graphic reconstruction and its implementation on GPUs.Journal of Structural Biology170, 1 (2010), 146–151. doi:10.1016/j.jsb.2010.01.021

2010 doi
[31]

Yuke Wang, Boyuan Feng, Zheng Wang, Guyue Huang, and Yufei Ding. 2023. TC-GNN: Bridging Sparse GNN Computation and Dense Tensor Cores on GPUs. InUSENIX Annual Technical Conference (ATC)

2023
[32]

Anjiang Wei, Tianran Sun, Yogesh Seenichamy, Hang Song, Anne Ouyang, Azalia Mirhoseini, Ke Wang, and Alex Aiken. 2025. Astra: A Multi-Agent System for GPU Kernel Performance Optimization. InNeurIPS 2025 Fourth Workshop on Deep Learning for Code

2025
[33]

Nitish Srivastava, Hanchen Jin, Jie Liu, David Albonesi, and Zhiru Zhang. 2020. MatRaptor: A Sparse-Sparse Matrix Multiplication Accelerator Based on Row- Wise Product. In2020 53rd Annual IEEE/ACM International Symposium on Mi- croarchitecture (MICRO). 766–780. doi:10.1109/MIC...

2020
[34]

Zihao Ye, Ruihang Lai, Junru Shao, Tianqi Chen, and Luis Ceze. 2023. Sparse- TIR: Composable Abstractions for Sparse Compilation in Deep Learning. In Proceedings of the 28th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, ...

2023
[35]

Yue Zhao, Jiajia Li, Chunhua Liao, and Xipeng Shen. 2018. Bridging the gap between deep learning and sparse matrix format selection. InProc. 23rd ACM SIGPLAN Symp. on Principles and Practice of Parallel Programming (PPoPP). 94– 108

2018
[36]

Xinguo Zhu, Shaohui Peng, Jiaming Guo, Yunji Chen, Qi Guo, Yuanbo Wen, Hang Qin, Ruizhi Chen, Qirui Zhou, Ke Gao, et al. 2025. QiMeng-Kernel: Macro- Thinking Micro-Coding Paradigm for LLM-Based High-Performance GPU Kernel Generation.arXiv preprint arXiv:2511.20100(2025). 12

2025
[37]

Min Wu, Huizhang Luo, Fenfang Li, Yiran Zhang, Zhuo Tang, Kenli Li, Jeff Zhang, and Chubo Liu. 2025. HSMU-SpGEMM: Achieving High Shared Memory Utilization for Parallel Sparse General Matrix-Matrix Multiplication on Modern GPUs. In2025 IEEE International Symposium on High Perfo...

2025
[2006]

InPredicting Structured Data

A tutorial on energy-based learning. InPredicting Structured Data. MIT Press
[2017]

Sparse Matrix-Vector Multiplication on GPGPUs.ACM Trans. Math. Softw. 43, 4, Article 30 (Jan. 2017), 49 pages. doi:10.1145/3017994

2017 doi
[2022]

InProceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis(Dallas, Texas)(SC ’22)

AlphaSparse: generating high performance SpMV codes directly from sparse matrices. InProceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis(Dallas, Texas)(SC ’22). IEEE Press, Article 66, 15 pages

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.

[1] [1]

Rishabh Agarwal, Levi Melnick, Nicholas Frosst, Xuezhou Zhang, Ben Lengerich, Rich Caruana, and Geoffrey E. Hinton. 2021. Neural additive models: Interpretable machine learning with neural nets. InAdvances in Neural Information Processing Systems (NeurIPS), Vol. 34. 4699–4711

work page 2021

[2] [2]

Chris Burges, Tal Shaked, Erin Renshaw, Ari Lazier, Matt Deeds, Nicole Hamilton, and Greg Hullender. 2005. Learning to rank using gradient descent. InProc. 22nd Int. Conf. on Machine Learning (ICML). 89–96

work page 2005

[3] [3]

Zhe Cao, Tao Qin, Tie-Yan Liu, Ming-Feng Tsai, and Hang Li. 2007. Learning to rank: from pairwise approach to listwise approach. InProc. 24th Int. Conf. on Machine Learning (ICML). 129–136

work page 2007

[4] [4]

Xing Cong, FuKai Sun, YiFan Chen, Chenhao Xie, Yi Liu, and Depei Qian. 2025. CB-SpMV: A Data Aggregating and Balance Algorithm for for Cache-Friendly Block-Based SpMV on GPUs. InProceedings of the 39th ACM International Con- ference on Supercomputing. 149–160

work page 2025

[5] [5]

Davis and Yifan Hu

Timothy A. Davis and Yifan Hu. 2011. The University of Florida Sparse Matrix Collection.ACM Trans. Math. Software38, 1 (2011), 1:1–1:25

work page 2011

[6] [6]

Zhen Du, Jiajia Li, Yinshan Wang, Xueqi Li, Guangming Tan, and Ninghui Sun

[7] [7]

Ruibo Fan, Wei Wang, and Xiaowen Chu. 2024. DTC-SpMM: Bridging the Gap in Accelerating General Sparse Matrix Multiplication with Tensor Cores. InPro- ceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 3(La Jolla, CA, USA)(AS- PLOS ’24). Association for Computing Machinery, New...

arXiv 2024

[8] [8]

Salvatore Filippone, Valeria Cardellini, Davide Barbieri, and Alessandro Fanfarillo