Quantum Physics · arXiv:2611.16285 v1 · submitted 12 Nov 2026 · 18 references
Scaling Pêlagos: Multi-GPU Orchestration for Relay Belief-Propagation Decoding
The paper says
“Fault-tolerant quantum computing requires quantum error-correction (QEC) decoders that achieve low logical error rates under real-time operating constraints. These constraints motivate heuristic decoding algorithms whose error-correction performance must be evaluated through large-scale simulation.”
more of the abstract
High-throughput decoding accelerates this evaluation and the exploration of decoder parameters. Using multiple graphics processing units (GPUs) is a natural way to scale these simulations, but naively distributing syndrome batches introduces host-side preprocessing and output-collection overheads that limit scaling. To address these limitations, we extend the Pêlagos relay belief-propagation (Relay-BP) decoder with process-isolated orchestration, parallel host preprocessing, and shared-memory output. We evaluate both one-gross ([[144,12,12]]) and two-gross ([[288,12,18]]) codes in a multi-GPU environment. Specifically, for the one-gross circuit at R = 50, eight AMD Instinct MI300X GPUs and eight AMD Instinct MI355X GPUs achieve optimized end-to-end speedups of 5.68 × and 6.23 ×, respectively. For the two-gross circuit, the corresponding speedups are 6.92 × and 7.01 ×. When throughput is calculated using GPU decoding time, the corresponding two-gross speedups are 7.58 × and 7.45 ×, indicating near-linear GPU scaling. We deploy Pêlagos on Lux, Oak Ridge National Laboratory's AMD Instinct MI355X-based supercomputer, as a pathfinding application for high-throughput QEC simulation. This deployment provides a concrete quantum-computing use case for the AI + HPC infrastructure supporting the Genesis Mission's scientific-discovery goals. These end-to-end measurements demonstrate a practical path to accelerating large-scale QEC simulation through efficient multi-GPU decoding.
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. Solid systems engineering paper: the multi-GPU orchestration works and the scaling curves are credible, but the 'near-linear' label and precise speedup ordering rest on three-repetition medians with no reported variance. This line is wrong
2 major objections · 4 minor
How often objections from reviews like this one are right: not yet measured
Not checked: figures, code, what the 18 references say.
The paper says, at Section IV-A2 and Table III
The review did not quote this passage.
Pith says: Objection 1 of 2 · major
The headline eight-GPU speedups, especially the P\'elagos-Parallel series, rest on three measured repetitions with no variance, confidence interval, or run-to-run spread. This matters most for the Parallel metric, which is defined as the maximum elapsed worker decode time: with S=1, shard completion times are data-dependent (the paper itself states this at sentence [b57] and at [b161] for equal batch sizes), so at G=8 the Parallel throughput is an extreme order statistic over eight independent shards.
more of objection 1
Extreme statistics have substantially higher sampling variance than means, and three repetitions cannot characterize that variance. The comparisons of 0.09x (two-gross E2E, MI300X 6.92x vs MI355X 7.01x) and 0.55x (one-gross E2E, 5.68x vs 6.23x) are therefore not statistically supported. I recommend reporting per-repetition values or confidence intervals for the key points, or softening the precise ordering and 'near-linear' claims in the abstract and conclusion.
The paper says, at Section IV-D
The review did not quote this passage.
Pith says: Objection 2 of 2 · major
The LER section is appropriately non-comparative: the paper states that small failure counts do not support an accuracy comparison across GPU counts (sentence [b210]) and reports zero failures for two-gross. This is fine as a correctness sanity check. However, I note that the paper does not report the number of syndromes or failures behind the one-gross range 8.14e-5 to 3.91e-4, which would allow a reader to judge whether the observed LER values are consistent with the published Pelagos study.
more of objection 2
Adding these counts would strengthen the sanity check without changing its non-comparative status.
4 minor objections
The paper says, at Section IV-A3
Pith says: minor objection 1 of 4
The experimental setup reports one warm-up followed by three measured repetitions, but the paper does not report the per-repetition values or any measure of dispersion. A sentence stating that the medians were stable, or a small table of min/max, would address the main statistical concern without requiring a full error-bar treatment.
The paper says, at Table III
Pith says: minor objection 2 of 4
The table reports throughput in iterations/s and decodes/s but not the per-point repetitions or any error bars. Adding a symbol for 'no spread reported' would be transparent.
show 2 more
The paper says, at Section III-C
Pith says: minor objection 3 of 4
The phrase 'validated configuration cache' is clear, but the paper does not state whether the autotuned configuration at B=1,024 was validated on both platforms or whether any platform-specific differences were observed. A sentence clarifying this would help.
The paper says, at General
Pith says: minor objection 4 of 4
Minor typos and formatting issues exist (e.g., 'P\'elagos' spacing in the title, the stray word 'syndrome' after sentence [b214] in the extracted text). These do not affect the content.
What would settle it
Run at least 30 measured repetitions, or bootstrap the raw per-repetition timings if available, of the one-GPU and eight-GPU P\'elagos-Parallel and P\'elagos-E2E points for both circuits on both platforms. Report the full distribution of S_v(G) from Eq. (1), with particular attention to max worker decode time at G=1 versus G=8. If the 95% bootstrap or empirical interval for the two-gross eight-GPU Parallel speedup on either platform includes values below roughly 7.0, or if the one-gross cross-platform E2E gap (5.68x vs 6.23x) falls within the within-platform run-to-run spread, then the exact ordering and the 'near-linear' wording are unsupported. If the intervals exclude those thresholds, the concern is resolved.
from the skeptic's reading
How the review went
4 readings by deepseek-v4-flash · 13 Nov 2026
- Reader holds up, with conditions
- Skeptic partly agrees
- Editor wrote the verdict above
- Referee major revision: 2 major objections, 4 minor
Not run on this paper: the simulated authors' defence.
Pith did not check this review's objections against the paper.
The review in full
The review in brief, machine-written
This is a straightforward systems-engineering extension of the authors' own Pelagos decoder. The new piece is node-local multi-GPU orchestration: one process per GPU, parallel host preprocessing, and shared-memory output. The core claim—that this design scales better than the single-process baseline—is well supported by the data. The comparison is clean: same per-GPU workload, same decoder parameters, same hardware, three repetitions. The LER section is correctly labeled non-comparative. The ablation and microarchitecture analysis add useful context.
What the paper does well: it identifies a real bottleneck (serial host preprocessing and context management in the original Pelagos), implements a straightforward fix, and measures the improvement. The scaling curves for the two-gross circuit are particularly clean. The deployment on Lux is a nice demonstration of real-world applicability.
Where the paper is soft: the headline speedups and the 'near-linear' label in the abstract and conclusion rest on median-of-three measurements with no reported variance or confidence intervals. The stress-test note is right that the Parallel series, which uses the maximum elapsed worker decode time, is an extreme order statistic and therefore has higher sampling variance than a mean. Some comparisons in Table III are as small as 0.09x; without any measure of spread, the precise ordering and the 'near-linear' wording are not statistically supported. The authors acknowledge data-dependent completion times (sentence [b57]) but do not report run-to-run spread. This does not threaten the robust qualitative result—at eight GPUs, E2E beats Baseline by 2.64x/2.07x for one-gross and 1.48x/1.36x for two-gross—but the precise speedup numbers and near-linear wording are load-bearing in the abstract and conclusion. A component-wise ablation (process isolation vs. parallel preprocessing vs. shared-memory output) would also strengthen attribution of the gains.
Who this is for: researchers working on high-throughput QEC simulation, especially those using GPU clusters. The paper is a legitimate extension of the Pelagos program and deserves a serious referee. The soft spots are about statistical reporting, not about the validity of the approach.
Recommendation: accept with minor revisions. The authors should report variance or confidence intervals for the key throughput measurements, and soften the 'near-linear' claim to something like 'approaches linear scaling' or 'shows near-linear scaling in GPU decoding time for the two-gross circuit.' The qualitative result is solid and the paper is a useful contribution.
The strongest objection
The central quantitative claim—eight-GPU E2E speedups of 5.68x–7.01x and 'near-linear' P\'elagos-Parallel scaling of 7.58x/7.45x—requires the median-of-three measurements in Section IV-A3 to be stable. The least secure part is the Parallel series, whose throughput is computed from the maximum elapsed worker decode time (Section IV-A2). Because the S=1 workload stops each syndrome at its first valid candidate, shard completion times are data-dependent (Section II-A, [b57]); at G=8 the Parallel metric is therefore an extreme order statistic over eight independent 1,024-syndrome shards. Extreme statistics have substantially higher sampling variance than means, and three repetitions cannot characterize that variance. Table III contains comparisons as small as 0.09x (two-gross eight-GPU E2E speedups, MI300X 6.92x vs MI355X 7.01x) and 0.55x (one-gross eight-GPU E2E speedups, 5.68x vs 6.23x); without confidence intervals, these orderings and the 'near-linear' label are not statistically supported. The authors acknowledge data-dependent completion times, but they do not report run-to-run spread. This does not threaten the robust qualitative result—at eight GPUs, E2E beats Baseline by 2.64x/2.07x for one-gross and 1.48x/1.36x for two-gross—but the precise speedup numbers and near-linear wording are load-bearing in the abstract and conclusion.
I read the paper as an empirical systems claim: the orchestration changes remove host-side bottlenecks so that independent syndrome shards can scale across GPUs. For the strongest claim to hold, the measured speedup ratios must not be dominated by measurement noise. That condition is least secure for the Parallel series, because it is based on an extreme statistic—the maximum worker decode time—over data-dependent shard completion times, with only three repetitions and no reported variance. The reader's weakest_assumption identifies this same statistical-stability concern. I do not see a separate load-bearing baseline-fairness problem: the baseline is described as the original one-process multi-GPU path, and the comparison is internally consistent. A component-wise ablation of process isolation versus parallel preprocessing versus shared-memory output would be informative, but it is not required for the integrated-design claim as stated. There is no circularity: the speedups are measured against an independent baseline implementation. The public repository and detailed parameter tables support reproducibility, though raw timing data are absent. Because the qualitative conclusion is robust and the precise numbers require additional repetitions to verify, the appropriate disposition remains the reader's CONDITIONAL verdict; my analysis does not move it.
The referee's report
If the quoted speedups are stable, the paper makes a useful systems contribution: it shows that node-local multi-GPU decoding of independent syndrome shards can approach linear scaling once host preprocessing and output collection are restructured, and it demonstrates the design on two distinct AMD platforms and on a large HPC system. The methodology is fair in the dimensions that matter: the baseline and optimized variants use the same per-GPU workload, same Relay-BP parameters, three repetitions, and the speedup is a measured ratio with nothing fitted to produce the improvement. The paper also ships an implementation in a public repository and acknowledges the main caveats (data-dependent completion times, small LER failure counts, profiler limitations). The residual weakness is statistical: with only three repetitions and no reported run-to-run spread, the precise speedup orderings and the 'near-linear' wording are not strongly supported, even though the qualitative improvement over the baseline is likely robust.
Pith's reading of the paper (a machine's summary, not the authors')
Evaluating quantum error-correcting codes requires decoding enormous numbers of error syndromes, and simulation throughput therefore bounds how fast decoder design can proceed. This paper argues that when several GPUs in one node decode independent syndrome shards, the scaling bottleneck is not the decoding kernels but the host path that prepares syndromes and collects results. The authors restructure that path — one persistent process per GPU, concurrent shard preparation, and shared-memory output — and report eight-GPU end-to-end speedups of 5.68×–7.01× for two quantum-LDPC codes, up from 2.20×–4.75× for the previous one-process design. Measured on GPU time alone, the two-gross code scales 7.58×/7.45×, close to the ideal eightfold. If these numbers hold, node-local multi-GPU decoding can nearly eliminate orchestration overhead, directly accelerating the large simulations needed to vet decoders for fault-tolerant quantum computers.
What carries the argument. The load-bearing object is the orchestration layer, not the decoder: three host-side changes. First, process isolation — each GPU gets one persistent worker process that sets its visible-device assignment before the GPU runtime initializes, so it owns a single private HIP context and runs the unmodified single-GPU decoder. Second, parallel host preprocessing — the total batch is split into contiguous per-GPU ranges prepared concurrently by a CPU thread pool and concatenated once before dispatch. Third, shared-memory output — one shared array is allocated in the shape of the global correction tensor, each worker copies its device result directly into its assigned slice, and only small metadata crosses process pipes. The paper deliberately leaves the Relay-BP kernels, layouts, and autotuned configuration untouched, pinning one validated configuration cache per system and circuit because the per-GPU problem shape stays fixed at 1,024 syndromes. The scaling ratios that carry the conclusion are computed with scaled-work analysis: per-GPU work is fixed, GPU count grows, and each variant is normalized to its own one-GPU throughput.
Core claim. On its own terms, the paper's claim is that syndrome shards were already perfectly independent — each GPU holds a full graph replica and never exchanges messages — so the multi-GPU scaling ceiling came entirely from host-side serialization. The previous organization ran all GPUs from one Python process, prepared the whole syndrome batch serially on the CPU, and shipped large correction arrays back through process pipes. The process-isolated design gives each physical GPU a persistent worker process with a private HIP context, prepares the per-GPU shards concurrently in a host thread pool, and has each worker copy its corrections directly into one shared-memory array. At relay depth $R=50$ and 1,024 syndromes per GPU, the one-gross ($[[144,12,12]]$) and two-gross ($[[288,12,18]]$) bivariate-bicycle memory circuits show eight-GPU end-to-end speedups of 5.68×/6.23× and 6.92×/7.01× on MI300X/MI355X GPUs, versus 2.20×–4.75× for the baseline; with host overhead excluded, the two-gross circuit reaches 7.58×/7.45×. In the authors' decomposition, the decisive effect is that CPU preprocessing time per batch no longer grows with GPU count, which is what lets aggregate decoding throughput track the number of devices.
The premise it rests on. The load-bearing premise is that the measured median of three warm-cache repetitions at each GPU count is stable enough to separate the variants and platforms — several decisive comparisons are close (the two-gross eight-GPU end-to-end gap between platforms is 0.09× and the one-gross gap is 0.55×), no variance or confidence intervals are reported, and the one-process-per-node Pêlagos baseline is taken as the fair measure of the prior path; if run-to-run noise is comparable to those gaps, the exact ordering and the near-linear label are fragile, though the qualitative improvement over the baseline would likely survive.
If the paper is right (Pith's inferences, not the authors')
Eight-GPU end-to-end scaling for the one-gross circuit rises from 2.20× to 5.68× on MI300X and from 3.22× to 6.23× on MI355X; for the two-gross circuit it rises from 4.64×/4.75× to 6.92×/7.01×.
With host preprocessing and result handling excluded, two-gross GPU decoding alone scales 7.58× (MI300X) and 7.45× (MI355X), close to the ideal eightfold, because shards are independent and each worker's batch stays fixed at 1,024 syndromes.
CPU preprocessing per batch stops scaling with GPU count: on MI355X, one-gross preparation grows from 0.132 s to 0.222 s across 1–8 GPUs instead of 0.129 s to 0.974 s, and two-gross from 0.446 s to 0.733 s instead of 0.437 s to 3.213 s.
Larger per-GPU batches raise throughput with diminishing returns up to the indexing ceiling $E \times B \le 2^{31}-1$, with observed knee batches $B^*(G)$ between 1,024 and 4,096 depending on circuit, platform, and GPU count.
The decoder configuration and parameters are reused without modification, so the orchestration changes carry no decoder-quality cost; logical error rates are reported only as a sanity check, with no two-gross failures observed after correcting the memory-strength interval.
My extension: the three fixes are transport-agnostic — any shard-parallel decoder with host-side syndrome preparation and output gathering, including matching or union-find decoders, could adopt the same process-isolated pattern without touching its kernels.
My extension: the signed-32-bit indexing bound on batch size is a soft ceiling; 64-bit indexing or splitting the edge arrays would permit larger per-GPU batches, and the paper's own occupancy data (up to 80.8%) suggest headroom before memory-bandwidth saturation binds.
My extension: because workers are persistent and communicate nothing, the node-local design should compose with cluster-level batch distribution; a multi-node run would test whether the per-node orchestration penalty stays flat and whether the reported 1,024-GPU throughput can be improved further per node.
My extension: the batch-size knee analysis implies a practical recipe for users — choose the smallest per-GPU batch reaching ~95% of peak throughput and then scale GPU count, rather than maximizing batch size on each device.
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
Fault-tolerant quantum computing requires quantum error-correction (QEC) decoders that achieve low logical error rates under real-time operating constraints. These constraints motivate heuristic decoding algorithms whose error-correction performance must be evaluated through large-scale simulation. High-throughput decoding accelerates this evaluation and the exploration of decoder parameters. Using multiple graphics processing units (GPUs) is a natural way to scale these simulations, but naively distributing syndrome batches introduces host-side preprocessing and output-collection overheads that limit scaling. To address these limitations, we extend the Pêlagos relay belief-propagation (Relay-BP) decoder with process-isolated orchestration, parallel host preprocessing, and shared-memory output. We evaluate both one-gross ([[144,12,12]]) and two-gross ([[288,12,18]]) codes in a multi-GPU environment. Specifically, for the one-gross circuit at R = 50, eight AMD Instinct MI300X GPUs and eight AMD Instinct MI355X GPUs achieve optimized end-to-end speedups of 5.68 × and 6.23 ×, respectively. For the two-gross circuit, the corresponding speedups are 6.92 × and 7.01 ×. When throughput is calculated using GPU decoding time, the corresponding two-gross speedups are 7.58 × and 7.45 ×, indicating near-linear GPU scaling. We deploy Pêlagos on Lux, Oak Ridge National Laboratory's AMD Instinct MI355X-based supercomputer, as a pathfinding application for high-throughput QEC simulation. This deployment provides a concrete quantum-computing use case for the AI + HPC infrastructure supporting the Genesis Mission's scientific-discovery goals. These end-to-end measurements demonstrate a practical path to accelerating large-scale QEC simulation through efficient multi-GPU decoding.
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-13
The authors' main claim, as the classifier picked it out 1.00
“These end-to-end measurements demonstrate a practical path to accelerating large-scale QEC simulation through efficient multi-GPU decoding.”
How the main claim is stated: asserted 1.00
What the abstract itself states, as probabilities: claims first 0.04 · states limitation 0.41 · human participants 0.02 · controlled comparison 0.30 · randomized assignment 0.01 · states quantitative result 0.99 · compares with prior results 0.29 · mentions code or data availability 0.04
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 |
|---|---|---|---|---|
| Fault-tolerant quantum computing requires quantum error-correction (QEC) decoders that achieve low logical error rates under real-time operating constraints. | background 1.00 | 0.05 | 0.03 | asserted 1.00 |
| These constraints motivate heuristic decoding algorithms whose error-correction performance must be evaluated through large-scale simulation. | background 0.99 | 0.08 | 0.02 | asserted 0.99 |
| High-throughput decoding accelerates this evaluation and the exploration of decoder parameters. | background 1.00 | 0.08 | 0.04 | asserted 1.00 |
| Using multiple graphics processing units (GPUs) is a natural way to scale these simulations, but naively distributing syndrome batches introduces host-side preprocessing and output-collection overheads that limit scaling. | background 0.56 | 0.18 | 0.03 | asserted 0.99 |
| To address these limitations, we extend the P\^elagos relay belief-propagation (Relay-BP) decoder with process-isolated orchestration, parallel host preprocessing, and shared-memory output. | contribution 0.85 | 0.94 | 0.10 | asserted 0.99 |
| We evaluate both one-gross ($[[144,12,12]]$) and two-gross ($[[288,12,18]]$) codes in a multi-GPU environment. | method 0.69 | 0.94 | 0.04 | asserted 0.94 |
| Specifically, for the one-gross circuit at $R=50$, eight AMD Instinct MI300X GPUs and eight AMD Instinct MI355X GPUs achieve optimized end-to-end speedups of $5.68\times$ and $6.23\times$, respectively. | result 1.00 | 0.96 | 0.11 | asserted 1.00 |
| For the two-gross circuit, the corresponding speedups are $6.92\times$ and $7.01\times$. | result 1.00 | 0.95 | 0.08 | asserted 1.00 |
| When throughput is calculated using GPU decoding time, the corresponding two-gross speedups are $7.58\times$ and $7.45\times$, indicating near-linear GPU scaling. | result 0.87 | 0.96 | 0.15 | hedged possibility 0.58 |
| We deploy P\^elagos on Lux, Oak Ridge National Laboratory's AMD Instinct MI355X-based supercomputer, as a pathfinding application for high-throughput QEC simulation. | contribution 0.59 | 0.94 | 0.06 | asserted 0.99 |
| This deployment provides a concrete quantum-computing use case for the AI + HPC infrastructure supporting the Genesis Mission's scientific-discovery goals. | interpretation 0.87 | 0.53 | 0.05 | asserted 0.98 |
| These end-to-end measurements demonstrate a practical path to accelerating large-scale QEC simulation through efficient multi-GPU decoding. | interpretation 0.99 | 0.90 | 0.85 | asserted 1.00 |
What kind of paper the classifier reports this is: method or tool 1.00 · evidence from simulation or computation 0.85
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-13: 1 request, 9,126 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 (4)
Figures are the authors', reproduced from the paper.
References (18)
- [1] M. E. Beverland, M. Carroll, A. W. Cross, and T. J. Yoder, “Fail fast: Techniques to probe rare events in quantum error correction,” arXiv:2511.15177, 2025. [Online]. Available: https://arxiv.org/abs/2511. 15177 on PitharXiv
- [2] S. Bravyi, A. W. Cross, J. M. Gambetta, D. Maslov, P. Rall, and T. J. Yoder, “High-threshold and low-overhead fault-tolerant quantum memory,”Nature, vol. 627, no. 8005, pp. 778–782, Mar. 2024 on Pith
- [3] T. M ¨uller, T. Alexander, M. E. Beverland, M. B ¨uhler, B. R. Johnson, T. Maurer, and D. Vandeth, “Improved belief propagation is sufficient for real-time decoding of quantum memory,” arXiv:2506.01779, 2025. [Online]. Available: https://arxiv.org/abs/2506.01779 on PithPith's reviewarXiv
- [4] C. Mayer, A. Ganti, U. Onunkwo, T. Metodi, B. Anker, and J. Skryzalin, “Rare event simulation of quantum error-correcting circuits,” arXiv:2509.13678, 2025. [Online]. Available: https://arxiv.org/ abs/2509.13678 on PithPith's reviewarXiv
- [5] S. Bravyi and A. Vargo, “Simulation of rare events in quantum error correction,”Phys. Rev. A, vol. 88, no. 6, p. 062308, 2013 on Pith
- [7] D. Diamantopoulos, L. von Niederh ¨ausern, A. S. Anghel, R. Pletka, A. Kayi, T. M ¨uller, N. Papandreou, J. Blanusa, S. Sarafijanovic, N. M. Gonzalez, F. Abel, C. Hagleitner, S. Seelam, B. Johnson, R. Haas, and H. Pozidis, “P ˆelagos: An adaptive GPU decoder for error correcti... on Pith
- [8] Oak Ridge Leadership Computing Facility, “Lux: ORNL’s AI+ HPC supercomputer,” accessed: Sep. 29, 2026. [Online]. Available: https://www.olcf.ornl.gov/olcf-resources/compute-systems/lux/ on Pith
- [9] AMD, “AMD accelerates scientific discovery: Powering next-gen supercomputers and leading HPC and AI innovation,” 2025, accessed: Oct. 16, 2026. [Online]. Available: https://www.amd.com/en/blogs/ 2025/amd-accelerates-scientific-discovery-powering-next-gen.html on Pith
- [10] P. Panteleev and G. Kalachev, “Degenerate quantum LDPC codes with good finite length performance,”Quantum, vol. 5, p. 585, Nov. 2021. [Online]. Available: http://dx.doi.org/10.22331/q-2021-11-22-585 on Pithdoi:10.22331/q-2021-11-22-585
- [11] J. Roffe, D. R. White, S. Burton, and E. Campbell, “Decoding across the quantum low-density parity-check code landscape,”Phys. Rev. Res., vol. 2, p. 043423, Dec 2020. [Online]. Available: https://link.aps.org/doi/10.1103/PhysRevResearch.2.043423 on PithPith's reviewdoi:10.1103/physrevresearch.2.043423
- [12] P. Tillet, H. T. Kung, and D. Cox, “Triton: An intermediate language and compiler for tiled neural network computations,” inProc. 3rd ACM SIGPLAN Int. Workshop Mach. Learn. Program. Lang., Jun. 2019, pp. 10–19 on Pith
- [13] AMD, “AMD Instinct MI300 Series Accelerators,” accessed: Aug. 30, 2026. [Online]. Available: https://www.amd.com/en/products/ accelerators/instinct/mi300.html on Pith
- [14] AMD, “AMD Instinct MI355X GPUs,” accessed: Aug. 30, 2026. [Online]. Available: https://www.amd.com/en/products/accelerators/ instinct/mi350/mi355x.html on Pith
- [15] J. L. Gustafson, “Reevaluating Amdahl’s law,”Commun. ACM, vol. 31, no. 5, pp. 532–533, May 1988 on Pith
- [16] NVIDIA, “QEC decoders,” NVIDIA CUDA-Q QEC documentation, accessed: Sep. 21, 2026. [Online]. Available: https://nvidia.github.io/ cudaq-qec/components/qec/decoders.html on Pith
- [17] J. Ansel, S. Kamil, K. Veeramachaneni, J. Ragan-Kelley, J. Bosboom, U.-M. O’Reilly, and S. Amarasinghe, “OpenTuner: An extensible frame- work for program autotuning,” inProc. 23rd Int. Conf. Parallel Archit. Compilation Techn., Aug. 2014, pp. 303–316 on Pith
- [18] T. Chen, T. Moreau, Z. Jiang, L. Zheng, E. Yan, H. Shen, M. Cowan, L. Wang, Y . Hu, L. Ceze, C. Guestrin, and A. Krishnamurthy, “TVM: An automated end-to-end optimizing compiler for deep learning,” in Proc. 13th USENIX Symp. Oper. Syst. Design Implement.Carlsbad, CA, USA: USEN... on Pith
- [2025] [Online]. Available: https://arxiv.org/abs/2506.03094 on PithPith's reviewarXiv
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