Performance · arXiv:2611.17212 v1 · submitted 12 Nov 2026 · 23 references
Theoretical and Empirical Analysis of Sparse Convolution
The paper says
“Deep neural networks for image processing are increasingly deployed on resource-constrained edge devices such as drones, medical systems, and smartphones, where limited computational resources and memory bandwidth pose significant challenges for efficient inference.”
more of the abstract
Pruning during training often produces highly sparse convolutional kernels, offering the potential to significantly reduce computation and memory requirements. However, exploiting this sparsity efficiently at runtime remains challenging due to irregular memory access patterns and workload imbalance across processing elements. In this work, we investigate the standard convolution with sparse weights and analyze its performance characteristics through roofline analysis, showing that a 3 x 3 sparse convolution achieves an arithmetic intensity of approximately 10 FLOP/byte compared to roughly 96 FLOP/byte for its dense counterpart. We propose techniques for an efficient sparse convolution at high sparsities. Preliminary results demonstrate that our approach achieves upto 1.65x speedup as compared to dense convolution on NVIDIA A100 and upto 1.52x on NVIDIA Jetson Nano (Tegra X1) , motivating further exploration of direct convolution as a practical path to efficient sparse inference on modern accelerators/edge devices.
from the abstract
Pith says
Machine review · deepseek-v4-flash · 13 Nov 2026 · what was read was not recorded · not checked by a person
It can be wrong. Challenge this review or reply to it.
Holds up, with conditions.
2 major objections · 5 minor
How often objections from reviews like this one are right: not yet measured
Not checked: figures, code, what the 23 references say.
The paper says, at §5.2, §6, Appendix
The review did not quote this passage.
Pith says: Objection 1 of 2 · major
The load-balance transferability of the measured speedups is the paper's main unresolved point. Section 5.2 states the mapping is load-balanced 'when sparsity per output channel is similar' (b115), and the evaluation uses weights generated with Python's random module (b133) at uniform per-channel sparsity, with the artifact appendix confirming fixed-seed random masks.
more of objection 1
Real magnitude-pruned CNNs under global pruning have strongly skewed per-OC nonzero counts, and because warp progress is governed by the slowest thread/OC in the group, the warp mapping degrades exactly under that skew. At 98% sparsity with IC=32, K=3, the mean is only ≈5.8 nonzeros per OC, so the max rather than the mean controls runtime. The paper's own §7 lists pruned ResNet evaluation as future work, yet the abstract claims a 'practical path to efficient sparse inference'; these two statements are in tension. I ask for either (a) an added experiment with realistic non-uniform per-OC sparsity (e.g., magnitude-pruned ResNet layers, or a synthetic per-OC sparsity skew sweep with reported per-OC nonzero statistics and warp-idle measurements), or (b) a reframing of the abstract and conclusion claims to the tested per-channel-uniform regime. Note that the cited literature (Park et al., reference [16]) addresses this exact imbalance via guided pruning; the paper should engage with that mitigation rather than leaving it implicit.
The paper says, at §6.1, §6.2, Fig. 7
The review did not quote this passage.
Pith says: Objection 2 of 2 · major
The paper does not decompose the large gap between measured performance and the roofline ceilings, which is material because the kernel's stated design goal is to keep realized memory traffic 'close to the lower bound implied by the roofline model' (§5).
more of objection 2
At 98% sparsity on the A100 (OC=128), Fig. 7a shows measured throughput of about 0.8 TFLOP/s at AI ≈ 1.9, i.e., an effective bandwidth of roughly 0.4 TB/s against a 2 TB/s roof — far below both roofs while the kernel is in the supposedly memory-bound regime. The paper attributes the gap to 'irregular sparse memory accesses, reduced memory coalescing' but does not quantify the relative contributions of load imbalance versus uncoalesced traffic, nor report occupancy or per-OC nonzero distributions. Since the kernel's claimed advantage over naive sparse implementations is precisely its bandwidth and balance behavior, reporting achieved DRAM bandwidth and a lane-utilization metric for the tested configurations would substantiate the roofline-guided design narrative and would also help reviewers interpret why speedup saturates at about 1.65× despite 10× FLOP reduction.
5 minor objections
The paper says, at Throughout
Pith says: minor objection 1 of 5
Typos: 'upto' in the abstract and Section 1; 'esily' and 'Jetso Nano' in the artifact appendix; a duplicated period in the first paragraph of Section 7. The figure axis in Fig. 8 has garbled exponent formatting ('10 7, 6 × 10 8, 2 × 10 7'), which should be rendered as 10^-7, 6×10^-8, 2×10^-7.
The paper says, at §6.1, Fig. 7a
Pith says: minor objection 2 of 5
The sentence describing 'dense performance decreases from approximately 2.5 TFLOP/s to 0.5 TFLOP/s as sparsity increases ... considering only non-zero computations' is confusing: dense convolution performs the same FLOPs regardless of weight sparsity, so the displayed dense throughput must be computed against the pruned FLOP count. Please clarify what is being plotted.
show 3 more
The paper says, at §5.2
Pith says: minor objection 3 of 5
The mapping parameters (tile size, COL_PER_WARP) are said to be 'selected through an ablation study comparing multiple configurations,' but no ablation results appear in the paper. Either include the ablation table or cite where it is reported.
The paper says, at §6
Pith says: minor objection 4 of 5
The baseline is described only as 'PyTorch's dense convolution.' Since Section 2 argues that Winograd is the standard fast 3×3 implementation, please document which cuDNN kernel PyTorch dispatches for the evaluated configuration (Winograd, implicit GEMM, or direct), so the reader can map the 1.65× claim onto the baseline actually used.
The paper says, at §4.2, Tables 2–3
Pith says: minor objection 5 of 5
The tables are described as 'theoretical time based speedup' with an optimistic overlap assumption that the paper acknowledges (b84–b85). A one-line reminder in each table caption that the values assume full compute/communication overlap would prevent readers from misreading them as measured results.
What would settle it
Take a trained ResNet-18 (or ResNet-50), apply global magnitude pruning to 98% weight sparsity, extract the stride-1 3×3 conv layers, and run the released kernel per layer with the same benchmarking protocol as §6.1; record per-layer speedup versus PyTorch's dense convolution and the per-output-channel nonzero-count distribution. Also run a controlled ablation: keep total sparsity at 98% but construct a per-OC nnz distribution with, e.g., 25% of output channels empty and 25% holding twice the average nnz, and measure whether speedup relative to the balanced random mask collapses below 1. If per-layer speedups track Fig. 5 even under skewed distributions, the concern is resolved; if any layer drops below 1, the practical claim needs re-scoping to per-channel-balanced sparsity patterns.
from the skeptic's reading
How the review went
3 readings by deepseek-v4-flash · 13 Nov 2026
- Reader holds up, with conditions
- Skeptic agrees
- Referee major revision: 2 major objections, 5 minor
Not run on this paper: the editor, the simulated authors' defence.
Pith did not check this review's objections against the paper.
The review in full
The strongest objection
The kernel's speedup depends on the warp mapping in §5.2 being load-balanced, and §5.2 states this holds only "when sparsity per output channel is similar." The evaluation, however, uses synthetic weights generated with Python's random module (§6), i.e., unstructured masks with at best i.i.d. per-channel sparsity; the artifact appendix confirms only that random sparse kernels with a fixed seed are used. Real magnitude-pruned CNNs such as ResNet often have strongly non-uniform sparsity across output channels, especially under global pruning: some channels retain many nonzeros while others are nearly or entirely zero. In the proposed mapping (§5.2, Fig. 3), threads in a warp are partitioned by output column and then iterate over their assigned output channel's nonzero list, so warp progress is governed by the slowest thread/OC in the group; per-OC skew directly converts into idle lanes. Because the claimed 1.65×/1.52× speedups are measured at 98% overall sparsity, where the mean number of nonzeros per OC is small (≈6 for the A100 configuration with IC=32, K=3), the maximum over OCs rather than the mean can control runtime; the random-pattern numbers therefore do not bound real-pattern performance. The paper's own Section 7 lists evaluation on pruned ResNet models as future work, confirming that the broader practical claim in the abstract (sparse direct convolution as "a practical path to efficient sparse inference on modern accelerators/edge devices") is untested for realistic pruning distributions. This is an external-validity gap, not an internal inconsistency, but it is load-bearing for the abstract's practical claim.
Reading the paper in good faith, the narrow benchmark claim is well supported: the released artifact exists, the kernel is described in detail in Algorithm 1, and the speedup numbers are internally plausible for the stated random-sparsity setup and PyTorch dense baseline. The load-bearing weakness is not the benchmark itself but the generalization step from these measurements to the practical claim in the abstract and conclusion. Section 5.2 explicitly conditions the thread-mapping strategy's load balance on similar per-output-channel sparsity, and the evaluation never checks that condition against real pruning distributions. Real magnitude-pruned networks can produce highly skewed per-channel nonzero counts, and because warp execution time is set by the slowest thread, such skew directly attacks the mechanism that produces the measured speedups. The paper acknowledges this gap by listing pruned ResNet evaluation as future work, which confirms the limitation rather than resolving it. The reader's weakest assumption identifies the same issue, so I agree with the conditional verdict; my concern does not move the verdict because the proposed test would only sharpen the conditionality already stated. One specific check—benchmarking the kernel on pruned ResNet layers or on synthetic skew-controlled nonzero distributions—would settle whether the practical claim survives realistic sparsity patterns.
The referee's report
The contribution is sound as an engineering-plus-analysis data point: the roofline accounting is parameter-free and standard, the kernel design is coherent, and the empirical comparison is reproducible (GitHub artifact, fixed random seed, pybind11 bindings, error bars over ten runs, and a numerical-accuracy check against the PyTorch baseline). The reported speedups are genuine for the tested condition. The paper is also unusually honest about its own limits: it concedes that its mapping is load-balanced only when per-channel sparsity is similar (§5.2, sentence b115), that the Winograd speedup tables assume optimistic overlap (b84–b85), and that evaluation on pruned ResNet models is future work (§7). The main gap is that the central practical claim — that sparse direct convolution is 'a practical path to efficient sparse inference' — rests on random per-channel-uniform sparsity, which is exactly the condition under which the kernel's load-balance mechanism holds by construction. Real magnitude-pruned networks have skewed per-output-channel sparsity, and because warp progress is governed by the slowest thread in the group, that skew converts directly into idle lanes.
Pith's reading of the paper (a machine's summary, not the authors')
This paper argues that direct sparse convolution, despite its low arithmetic intensity, can be practically faster than dense convolution on both high-end GPUs and edge devices when weight sparsity exceeds roughly 90%. The authors identify the key bottleneck as memory bandwidth rather than compute, and design a kernel that mitigates this by packing each nonzero weight with its metadata into a single 32-bit word, tiling input data in shared memory, and mapping threads to output channels in a way that balances work when sparsity is uniform across channels. On an NVIDIA A100 they report up to 1.65× speedup over PyTorch’s dense convolution at 98% sparsity, and on a Jetson Nano up to 1.52×. The work is preliminary in the sense that it evaluates only a single 3×3 layer with randomly generated, uniformly sparse weights, but it makes a concrete case that the direct approach—often dismissed as too irregular—deserves renewed attention for sparse inference on bandwidth-limited hardware.
What carries the argument. The central object is the packed 32-bit weight entry: each nonzero weight is stored as a single unsigned 32-bit integer whose upper 16 bits hold the FP16 value, bits 15–8 encode the input channel index, bits 7–4 encode the kernel column offset, and bits 3–0 encode the kernel row offset. This format allows a thread to retrieve both the weight and its indexing metadata in one coalesced global memory load, which is critical because the kernel is memory-bound. The offset array (one entry per output channel, pointing into the packed array) serves as the sparse index structure, analogous to CSR row pointers. The shared-memory tile is the second key mechanism: each thread block loads a region of the input feature map (including the halo needed for 3×3 windows) once and reuses it across all output channels and output rows that the block computes, reducing redundant DRAM traffic. The thread-to-output-channel mapping (Figure 3) partitions a warp into four groups of eight threads, each group handling one output column and iterating over output channels in steps of 8, which balances work when sparsity is uniform per channel.
Core claim. The paper’s central claim is that direct sparse convolution, implemented with a packed 32-bit weight format that fuses an FP16 value with its indexing metadata, shared-memory tiling for input reuse, and a warp-level thread mapping that partitions output channels across thread groups, can deliver consistent wall-clock speedups over PyTorch’s dense convolution for 3×3 kernels at sparsities ≥ 90%. The roofline analysis shows that at these sparsities the arithmetic intensity falls below the ridge point of both the NVIDIA A100 (≈ 9.75 FLOP/byte) and the Jetson Nano (≈ 9.22 FLOP/byte), meaning the kernel is memory-bound. The packed format reduces the number of global memory transactions per nonzero element to a single 32-bit load, while shared-memory tiling amortizes input reads across multiple output channels. The thread mapping, which assigns groups of eight threads to one output column and iterates over output channels in steps of 32/COL_PER_WARP, is designed to keep load balanced when sparsity is similar across channels. The paper reports a maximum speedup of 1.65× on the A100 (OC=80, 98% sparsity) and 1.52× on the Jetson Nano (OC=40, 98% sparsity), with crossover points where sparse becomes faster than dense occurring between 90% and 93% sparsity depending on channel count. The authors explicitly note that the measured performance remains well below the theoretical memory-bandwidth roof, attributing this to irregular access patterns and load imbalance that the roofline model does not capture.
The premise it rests on. The thread mapping strategy balances load only when sparsity is similar across output channels, but the paper evaluates only randomly generated weights with uniform per-channel sparsity, not the non-uniform patterns produced by real pruning algorithms.
If the paper is right (Pith's inferences, not the authors')
If the kernel is integrated into a full inference pipeline, pruned networks such as ResNet-18/34/50 could see end-to-end latency reductions on edge GPUs without requiring architectural changes, because weight transfer from memory is a dominant cost.
The packed format’s use of FP16 for weight storage but FP32 for accumulation means that networks pruned to 90–98% sparsity can maintain FP32-equivalent numerical accuracy while reducing weight memory footprint by roughly 4× (FP32 → FP16) plus the index overhead.
The crossover sparsity (≈ 90–93% depending on OC) provides a practical threshold: below this sparsity, dense convolution (or Winograd) is still faster; above it, the direct sparse kernel becomes the better choice on the tested hardware.
Because the kernel is memory-bound, further speedups could come from hardware that improves effective bandwidth for irregular accesses (e.g., sparse memory controllers or on-chip caches optimized for gather patterns) rather than from increasing compute throughput.
The paper’s choice to evaluate only random, uniformly sparse weights is a significant limitation that the authors acknowledge indirectly. Real pruned networks (e.g., magnitude pruning, lottery-ticket rewinding) produce non-uniform sparsity across channels, which would break the load-balancing assumption and likely reduce the achieved speedup. A natural extension is to measure the kernel on actual
The theoretical speedup over Winograd (Tables 2 and 3) is computed assuming ideal memory behavior and perfect overlap of communication and computation, resulting in optimistic projections (4.5–5×). The measured speedups against dense convolution (1.2–1.65×) are far lower. This gap suggests that the primary benefit of the packed format is not in approaching the roofline bound but in avoiding the wo
The thread mapping strategy (eight threads per output column, iterating over OCs in steps of 8) implicitly assumes that the number of output channels is a multiple of the step size. For OC values that are not multiples of 8 (e.g., OC=48 is a multiple, but OC=80 is not mentioned), some threads may be idle or the mapping may require padding. The paper does not discuss how OC values that are not mult
Check this review
Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.
How often reviews like this one are right
Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.
How often objections from reviews like this one are right: not yet measured
Reviews by people
This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.
The paper
Abstract
Deep neural networks for image processing are increasingly deployed on resource-constrained edge devices such as drones, medical systems, and smartphones, where limited computational resources and memory bandwidth pose significant challenges for efficient inference. Pruning during training often produces highly sparse convolutional kernels, offering the potential to significantly reduce computation and memory requirements. However, exploiting this sparsity efficiently at runtime remains challenging due to irregular memory access patterns and workload imbalance across processing elements. In this work, we investigate the standard convolution with sparse weights and analyze its performance characteristics through roofline analysis, showing that a 3 x 3 sparse convolution achieves an arithmetic intensity of approximately 10 FLOP/byte compared to roughly 96 FLOP/byte for its dense counterpart. We propose techniques for an efficient sparse convolution at high sparsities. Preliminary results demonstrate that our approach achieves upto 1.65x speedup as compared to dense convolution on NVIDIA A100 and upto 1.52x on NVIDIA Jetson Nano (Tegra X1) , motivating further exploration of direct convolution as a practical path to efficient sparse inference on modern accelerators/edge devices.
The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.
abstract compiled · 2026-11-14
The authors' main claim, as the classifier picked it out 1.00
“Preliminary results demonstrate that our approach achieves upto 1.65x speedup as compared to dense convolution on NVIDIA A100 and upto 1.52x on NVIDIA Jetson Nano (Tegra X1) , motivating further exploration of direct convolution as a practical path to efficient sparse inference on modern accelerators/edge devices.”
How the main claim is stated: asserted 0.94
What the abstract itself states, as probabilities: claims first 0.03 · states limitation 0.56 · human participants 0.03 · controlled comparison 0.86 · randomized assignment 0.01 · states quantitative result 0.99 · compares with prior results 0.90 · mentions code or data availability 0.02
The abstract, sentence by sentence
This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.
| Sentence | Role | The authors' own work | States the main conclusion | Strength |
|---|---|---|---|---|
| Deep neural networks for image processing are increasingly deployed on resource-constrained edge devices such as drones, medical systems, and smartphones, where limited computational resources and memory bandwidth pose significant challenges for efficient inference. | background 1.00 | 0.05 | 0.02 | asserted 0.99 |
| Pruning during training often produces highly sparse convolutional kernels, offering the potential to significantly reduce computation and memory requirements. | background 1.00 | 0.09 | 0.03 | hedged possibility 0.85 |
| However, exploiting this sparsity efficiently at runtime remains challenging due to irregular memory access patterns and workload imbalance across processing elements. | gap 0.73 | 0.09 | 0.02 | asserted 0.99 |
| In this work, we investigate the standard convolution with sparse weights and analyze its performance characteristics through roofline analysis, showing that a 3 x 3 sparse convolution achieves an arithmetic intensity of approximately 10 FLOP/byte compared to roughly 96 FLOP/byte for its dense counterpart. | result 0.82 | 0.93 | 0.08 | asserted 1.00 |
| We propose techniques for an efficient sparse convolution at high sparsities. | contribution 0.93 | 0.82 | 0.14 | asserted 0.93 |
| Preliminary results demonstrate that our approach achieves upto 1.65x speedup as compared to dense convolution on NVIDIA A100 and upto 1.52x on NVIDIA Jetson Nano (Tegra X1) , motivating further exploration of direct convolution as a practical path to efficient sparse inference on modern accelerators/edge devices. | result 0.98 | 0.95 | 0.72 | asserted 0.94 |
What kind of paper the classifier reports this is: method or tool 0.99 · evidence from observation or experiment 0.84
What was examined, and what was not
Sources read
- arXiv listing abstract v1
Not examined
- full text
- figures and tables
- references and citing sentences
- relations to other papers
Levels run
- P abstract
Not run
- S sections
- T body sentences
- C citations
- R cross-paper relations
How the labels were made
Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-11-14: 1 request, 5,076 input tokens.
Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON
Figures (8)
Figures are the authors', reproduced from the paper.
References (23)
- [16] Jongsoo Park, Sheng Li, Wei Wen, Ping Tak Peter Tang, Hai Li, Yiran Chen, and Pradeep Dubey. Faster cnns with direct sparse convolutions and guided pruning, 2017 on Pith
- [1] Keiron O’Shea and Ryan Nash. An introduction to convolutional neural networks, 2015 on Pith
- [2] Abdelrahman Hosny, Marina Neseem, and Sherief Reda. Sparse bitmap compres- sion for memory-efficient training on the edge. In2021 IEEE/ACM Symposium on Edge Computing (SEC), pages 14–25, 2021 on Pith
- [3] Md Aamir Raihan and Tor M. Aamodt. Sparse weight activation training, 2020 on Pith
- [4] Marko Stamenovic, Nils L. Westhausen, Li-Chia Yang, Carl Jensen, and Alex Pawlicki. Weight, block or unit? exploring sparsity tradeoffs for speech enhance- ment on tiny neural accelerators, 2021 on Pith
- [5] Enshu Liu, Junyi Zhu, Zinan Lin, Xuefei Ning, Matthew B. Blaschko, Shengen Yan, Guohao Dai, Huazhong Yang, and Yu Wang. Efficient expert pruning for sparse mixture-of-experts language models: Enhancing performance and reduc- ing inference costs, 2024 on Pith
- [6] Torsten Hoefler, Dan Alistarh, Tal Ben-Nun, Nikoli Dryden, and Alexandra Peste. Sparsity in deep learning: Pruning and growth for efficient inference and training in neural networks, 2021 on Pith
- [7] Denis Kuznedelev, Eldar Kurtic, Eugenia Iofinova, Elias Frantar, Alexandra Peste, and Dan Alistarh. Accurate neural network pruning requires rethinking sparse optimization, 2023 on Pith
- [8] Trevor Gale, Matei Zaharia, Cliff Young, and Erich Elsen. Sparse gpu kernels for deep learning, 2020 on Pith
- [9] Nathan Bell and Michael Garland. Implementing sparse matrix-vector multipli- cation on throughput-oriented processors. InProceedings of the Conference on High Performance Computing Networking, Storage and Analysis, SC ’09, New York, NY, USA, 2009. Association for Computing Machinery on Pith
- [10] Kumar Chellapilla, Sidd Puri, and Patrice Simard. High performance convolu- tional neural networks for document processing. InProceedings of the Tenth International Workshop on Frontiers in Handwriting Recognition (IWFHR), La Baule, France, October 2006. HAL Id: inria-00112631 on Pith
- [11] Cristian Ramírez, Adrián Castelló, Héctor Martínez, and Enrique S. Quintana- Ortí. Parallel gemm-based convolution for deep learning on multicore risc-v processors.The Journal of Supercomputing, 80(9):12623–12643, 2024 on Pith
- [12] Erich Elsen, Marat Dukhan, Trevor Gale, and Karen Simonyan. Fast sparse convnets, 2019 on Pith
- [13] Keshvi Tuteja, Gregor Olenik, Roman Mishchuk, Yu-Hsiang Tsai, Markus Götz, Achim Streit, Hartwig Anzt, and Charlotte Debus. pyginkgo: A sparse linear algebra operator framework for python. InProceedings of the 54th International Conference on Parallel Processing, ICPP ’25, pag... on Pith
- [14] Shuai Lu, Jun Chu, and Xu T. Liu. Im2win: Memory efficient convolution on simd architectures. In2022 IEEE High Performance Extreme Computing Conference (HPEC), page 1–7. IEEE, 2022 on Pith
- [15] Yangjie Zhou, Mengtian Yang, Cong Guo, Jingwen Leng, Yun Liang, Quan Chen, Minyi Guo, and Yuhao Zhu. Characterizing and demystifying the implicit convo- lution algorithm on commercial matrix-multiplication accelerators, 2021 on Pith
- [17] Syed Asad Alam, Andrew Anderson, Barbara Barabasz, and David Gregg. Wino- grad convolution for deep neural networks: Efficient point selection, 2022 on Pith
- [18] Aleksandar Zlateski, Zhen Jia, Kai Li, and Fredo Durand. A deeper look at fft and winograd convolutions. InProceedings of the 2nd Conference on Systems and Machine Learning (SysML), Stanford, CA, USA, 2018 on Pith
- [19] Syed Asad Alam, Andrew Anderson, Barbara Barabasz, and David Gregg. Wino- grad convolution for deep neural networks: Efficient point selection.ACM Trans. Embed. Comput. Syst., 21(6), December 2022 on Pith
- [20] Samuel Williams, Andrew Waterman, and David Patterson. Roofline: an in- sightful visual performance model for multicore architectures.Commun. ACM, 52(4):65–76, April 2009 on Pith
show 3 more
- [21] NVIDIA Corporation. NVIDIA A100 Tensor Core GPU Datasheet. https: //www.nvidia.com/content/dam/en-zz/Solutions/Data-Center/a100/pdf/nvidia- a100-datasheet.pdf, 2020. Accessed: 2025-08-14 on Pith
- [22] Felix Liu, Albin Fredriksson, and Stefano Markidis. A gpu-accelerated interior point method for radiation therapy optimization.arXiv preprint arXiv:2405.03584, 2024 on PithPith's reviewarXiv
- [23] Wenzel Jakob, Jason Rhinelander, and Dean Moldovan. pybind11 – seamless op- erability between c++11 and python, 2017. https://github.com/pybind/pybind11 on Pith
Challenges and discussion
Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.
Come back by email
A short list of the week's newly reviewed papers. Nothing is sent until you confirm from your inbox, and every email has a link that stops it. No account.
No comments yet.
Sign in to comment