Distributed, Parallel, and Cluster Computing · arXiv:2611.16330 v1 · submitted 12 Nov 2026 · 70 references
Snoopie: A Multi-GPU Communication Profiler and Visualizer
The paper says
“With data movement becoming one of the most expensive bottlenecks in computing, the need for profiling tools to analyze communication becomes crucial for effectively scaling multi-GPU applications.”
more of the abstract
While existing profiling tools including first-party software by GPU vendors are robust and excel at capturing compute operations within a single GPU, support for monitoring GPU-GPU data transfers and calls issued by communication libraries is currently inadequate. To fill these gaps, we introduce Snoopie, an instrumentation-based multi-GPU communication profiling tool built on NVBit, capable of tracking peer-to-peer transfers and GPU-centric communication library calls. To increase programmer productivity, Snoopie can attribute data movement to the source code line and the data objects involved. It comes with multiple visualization modes at varying granularities, from a coarse view of the data movement in the system as a whole to specific instructions and addresses. Our case studies demonstrate Snoopie's effectiveness in monitoring data movement, locating performance bugs in applications, and understanding concrete data transfers abstracted beneath communication libraries. The tool is publicly available at https://github.com/ParCoreLab/snoopie.
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.
The passes disagreed. Reader: holds up. Skeptic: holds up only with conditions. Referee: major revision.
4 major objections · 22 minor
How often objections from reviews like this one are right: not yet measured
Not checked: figures, code, what the 70 references say.
The paper says, at §4.4, §5.5
The review did not quote this passage.
A classifier read this sentence of the paper as acknowledging the concern (probability 0.77):
“However, it should be noted that NVBit faces limitations in extracting this infor- mation from a significant portion of instructions.”
Pith says: Objection 1 of 4 · major
The source code line attribution method is a key differentiator (Table 1, Gap 3), but its accuracy is not validated. The paper acknowledges that NVBit's nvbit_get_line_info fails for 'a significant portion of instructions' (§4.4) and falls back to SASS-to-PTX matching using nvdisasm.
more of objection 1
No quantitative data is provided on: (i) what fraction of instructions are successfully matched, (ii) how often the matching is ambiguous, or (iii) how often the matched line is incorrect. The case studies do not independently verify the line numbers shown; they only demonstrate that the tool produces some output. Without this validation, the claimed source-line attribution for device-initiated P2P accesses (a headline contribution) may be unreliable for a substantial fraction of events. This is a load-bearing concern because source-line attribution is a central claim and the paper's own limitation statement (§4.4) flags the underlying NVBit limitation without showing that the fallback resolves it.
The paper says, at §5.5, Figure 12
The review did not quote this passage.
Pith says: Objection 2 of 4 · major
The accuracy evaluation is limited. The only quantitative accuracy comparison is for the stencil-p2p code with and without sampling (Figure 12), showing that the communication matrix pattern is similar but volumes are less balanced with sampling. This is a visual comparison, not a statistical measure.
more of objection 2
The paper claims 'Snoopie is accurate' (§5.5) but provides no ground-truth comparison for the exact profiling mode (e.g., comparing captured transfer counts against known program behavior or against a hardware counter). The accuracy of device attribution, object attribution, and source-line attribution is not quantitatively assessed. The authors should provide a more rigorous accuracy evaluation, at least for one case study, by comparing Snoopie's output against expected behavior derived from the source code or against a trusted baseline.
The paper says, at §4.7, §5.5
The review did not quote this passage.
Pith says: Objection 3 of 4 · major
The overhead measurements are reported for Stencil, BFS, and NCCL, but the numbers are inconsistent. In §5.5, the text says 'when the device-side filtering optimization is applied, the overhead of Snoopie is 16×, 2.04×, 96×, and 16.4× for Stencil, BFS, and NCCL, respectively.'
more of objection 3
This lists four numbers for three benchmarks. It appears the fourth number (16.4×) may be for NCCL, but the sentence structure is confusing. Additionally, the overhead for NCCL is reported as 96× in one place and 16.4× in another? The paper should clarify which overhead corresponds to which benchmark and ensure consistency.
The paper says, at §4.8, §5.4
The review did not quote this passage.
Pith says: Objection 4 of 4 · major
The paper acknowledges that Snoopie does not support MPI-based NCCL applications, which includes PyTorch distributed training. However, the CosmoFlow case study (§5.4) uses a single-process port of the model. This is a reasonable workaround for demonstration, but it limits the generality of the findings. The paper should discuss how representative this single-process port is of real distributed training workloads and whether the communication patterns observed would hold in a multi-process MPI setting.
22 minor objections
The paper says, at §1, Table 1
Pith says: minor objection 1 of 22
Table 1 lists 'Src Code Line Attribution' and 'Data Object Attribution' as checkmarks for Snoopie, but the paper does not provide a clear definition of what constitutes a data object. In §4.5.1, a data object is defined as 'the call stack of a memory allocation call', which is reasonable but could be clarified earlier.
The paper says, at §4.4
Pith says: minor objection 2 of 22
The description of SASS-to-PTX matching is vague. The paper says 'matching a disassembled SASS instruction with its PTX version, which has been previously mapped to a source code line in the output of nvdisasm.' It is unclear how the matching is performed (e.g., by opcode, by operands, by address?). A brief explanation of the matching algorithm would help reproducibility.
show 20 more
The paper says, at §5.5, Figure 11
Pith says: minor objection 3 of 22
Figure 11 shows overhead comparison but the y-axis is log-scaled and the bars are not labeled with exact values. The text provides some numbers, but it would be helpful to include the exact slowdown factors on the figure or in a table.
The paper says, at §4.5.1
Pith says: minor objection 4 of 22
The paper mentions 'custom wrapper allocation functions enabling programmers to include the variable name' but does not provide an example or API documentation. This would be useful for users.
The paper says, at §4.6
Pith says: minor objection 5 of 22
The support for Python programs is described, but the paper does not evaluate the overhead or accuracy for Python applications. The CosmoFlow case study is in PyTorch, but the overhead measurements in §5.5 do not include a Python-based benchmark.
The paper says, at §5.1, Demo 1
Pith says: minor objection 6 of 22
The BFS bug detection demo is interesting, but it is not clear whether the bug was introduced intentionally or was a real bug in the original code. The paper should clarify.
The paper says, at §5.2, Demo 3
Pith says: minor objection 7 of 22
The stencil bug demo (indexing error) is a useful illustration, but the paper does not explain how Snoopie's output specifically revealed the bug. The object view shows the second row being accessed instead of the first, but the user would need to know the intended behavior to spot the discrepancy. The paper should discuss whether Snoopie can automatically detect anomalies or if it requires manual inspection.
The paper says, at §4.2
Pith says: minor objection 8 of 22
The device attribution method using memory range tracking is described, but the paper does not discuss potential issues with memory reuse or deallocation. If a memory region is freed and reallocated to a different device, could the stale mapping cause incorrect attribution? The paper mentions that the approach 'persists beyond the lifetime of the memory allocation itself' but does not address this scenario.
The paper says, at §4.3, Figure 4
Pith says: minor objection 9 of 22
Figure 4 illustrates NVSHMEM address space layout but the caption is unclear. The text says 'NVSHMEM 2.7' and 'NVSHMEM 2.8/2.9' but the figure does not distinguish between versions. The figure should be clarified or the caption should explain the difference.
The paper says, at §5.3, Figure 9
Pith says: minor objection 10 of 22
Figure 9 shows the NCCL AllReduce visualization, but the node sizes and edge widths are not explained in the caption. The text mentions that GPU0 and GPU7 have smaller communication sizes for TREE, but the figure should be self-explanatory.
The paper says, at §4.7
Pith says: minor objection 11 of 22
The sampling method is described as using a pseudo-random number generator. The paper should specify the random number generator used and whether it is deterministic for reproducibility.
The paper says, at §5.5
Pith says: minor objection 12 of 22
The overhead for NCCL is reported as 96× in one sentence and 16.4× in another. This inconsistency needs to be resolved. Also, the sentence 'the overhead of Snoopie is 16×, 2.04×, 96×, and 16.4× for Stencil, BFS, and NCCL, respectively' lists four numbers for three benchmarks. Please clarify.
The paper says, at §4.8
Pith says: minor objection 13 of 22
The paper states 'Timeline information falls outside the scope of Snoopie.' This is a reasonable design choice, but the paper should discuss how users can combine Snoopie's output with timeline tools like Nsight Systems for a complete picture.
The paper says, at §5.5, Figure 12
Pith says: minor objection 14 of 22
Figure 12 shows exact vs. sampling profiling for stencil. The color scale is not explained. The paper should specify what the colors represent (e.g., number of transfers, bytes).
The paper says, at §6
Pith says: minor objection 15 of 22
The related work section is comprehensive but could benefit from a more direct comparison with ComScribe, which is the closest prior work. The paper mentions ComScribe but does not discuss specific differences in capability or methodology beyond what is in Table 1.
The paper says, at §4.5.1
Pith says: minor objection 16 of 22
The paper uses a splay tree for address range tracking. The choice of data structure is mentioned but not justified. A brief explanation of why a splay tree was chosen over other interval tree implementations would be helpful.
The paper says, at §4.1
Pith says: minor objection 17 of 22
The warp-level aggregation (one thread per warp compiles addresses) is described, but the paper does not discuss the potential for missing accesses if multiple threads in a warp access different remote addresses. The paper should clarify whether all addresses are captured or if there is a limitation.
The paper says, at §5.5
Pith says: minor objection 18 of 22
The paper reports overhead for SpMV in the text but SpMV is not introduced as a benchmark in the evaluation section. The paper should either include SpMV in the evaluation description or remove the reference.
The paper says, at §4.5.1
Pith says: minor objection 19 of 22
The paper mentions 'custom wrapper allocation functions' for variable names but does not provide an example or API. This would be useful for users.
The paper says, at §5.5
Pith says: minor objection 20 of 22
The overhead measurements include log compression time. The paper should also report the overhead without compression to understand the impact of compression.
The paper says, at §4.1
Pith says: minor objection 21 of 22
The paper states that 'a single thread compiles memory addresses targeted by memory operations from all other threads in the warp.' This could lead to missing accesses if multiple threads access different remote addresses. The paper should clarify whether all addresses are captured or if there is a limitation.
The paper says, at §5.5
Pith says: minor objection 22 of 22
The paper reports overhead for SpMV in the text but SpMV is not introduced as a benchmark in the evaluation section. The paper should either include SpMV in the evaluation description or remove the reference.
What would settle it
Run Snoopie on a small, known multi-GPU kernel (e.g., the BFS ring example from §5.1) where every remote access instruction is manually annotated with its correct source line. Compare Snoopie's reported line numbers against the ground truth for all captured remote accesses. Report: (a) fraction of accesses where nvbit_get_line_info succeeded, (b) fraction where SASS-to-PTX matching was used, (c) fraction of those where the matched line was correct, (d) fraction where no line could be assigned. If (c) is below 90% or (d) is above 10%, the source-line attribution claim is significantly weakened.
from the skeptic's reading
How the review went
3 readings by deepseek-v4-flash · 13 Nov 2026
- Reader holds up
- Skeptic partly agrees: says it holds up only with conditions SASS-to-PTX matching for source-line attribution is unvalidated and may fail silently for a large fraction of instructions, undermining a key claimed capability.
- Referee major revision: 4 major objections, 22 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 paper's central claim includes attributing inter-GPU memory operations to source code lines (Gap 3, §1). The method (§4.4) relies on NVBit's nvbit_get_line_info, which the authors acknowledge fails for 'a significant portion of instructions' (§4.4). When it fails, Snoopie falls back to matching SASS instructions to PTX instructions using nvdisasm output. This SASS-to-PTX matching is described only at a high level; no validation is reported. The paper provides no quantitative data on what fraction of instructions are successfully matched, how often the matching is ambiguous (multiple PTX instructions map to the same SASS pattern), or how often the matched line is incorrect. Without this validation, the claimed source-line attribution for device-initiated P2P accesses (a key differentiator from tools like Nsight Systems) may be unreliable for a substantial fraction of events. The case studies (BFS, stencil) do not independently verify the line numbers shown; they only demonstrate that the tool produces some output. This is a load-bearing concern because source-line attribution is a headline contribution (Table 1, 'Src Code Line Attribution' column) and the paper's own limitation statement (§4.4) flags the underlying NVBit limitation without showing that the fallback resolves it.
The reader's weakest_assumption correctly identifies the NVBit limitation as a concern. However, the reader's verdict (ACCEPT) treats this as a minor weakness that 'does not invalidate the central claim.' I argue this is more central: source-line attribution is a primary claimed differentiator (Table 1, §1 'attributing data movement to the source code line'). The paper's fallback SASS-to-PTX matching is described but never validated. The reader's rationale notes 'lack of quantitative accuracy evaluation' but does not connect this specifically to the source-line attribution pipeline. My concern is that the fallback may silently produce wrong or no lines for a large fraction of instructions, making the tool's key feature unreliable. The paper's own limitation (§4.4) says NVBit 'faces limitations in extracting this information from a significant portion of instructions' — this is an explicit warning that the primary method fails often, and the secondary method is unvalidated. I recommend CONDITIONAL: the paper should be accepted only if the authors provide validation of the SASS-to-PTX matching accuracy on a representative set of instructions, or clearly document the expected success rate and failure modes. This is not a rejection; the tool's other contributions (P2P capture, NCCL/NVSHMEM support, visualization) remain valuable. But the source-line attribution claim needs empirical backing to be credible.
The referee's report
If the claims hold, Snoopie fills a genuine gap in the GPU profiling tool landscape. The ability to attribute device-initiated P2P accesses to source lines and data objects is novel and could aid debugging and optimization of multi-GPU applications. The tool is open-source and the paper provides detailed implementation description. However, the significance is tempered by the acknowledged limitations: the tool is intra-node only, does not support MPI-based NCCL, and the source-line attribution relies on a fallback that is not validated.
Pith's reading of the paper (a machine's summary, not the authors')
The paper presents Snoopie, a profiling tool that captures inter-GPU data movement, including device-initiated peer-to-peer direct memory accesses and communication library calls (NCCL, NVSHMEM), which existing tools like Nsight Systems and HPCToolkit handle poorly or not at all. Snoopie attributes each data transfer to the source code line and the data object involved, and provides a multi-view interactive visualization. The authors demonstrate through case studies that Snoopie can locate performance bugs (e.g., incorrect flag allocation in BFS), compare communication patterns (e.g., ring vs. tree all-reduce algorithms), and visualize the communication footprint of different parallelization strategies in PyTorch. The tool is open-source and targets single-node multi-GPU systems.
What carries the argument. The central mechanism is dynamic binary instrumentation using NVBit, which allows Snoopie to intercept every load/store instruction executed on the GPU and check whether the accessed address belongs to a remote GPU's memory. Device attribution relies on NVIDIA's Unified Virtual Addressing (UVA) to map pointer addresses to device IDs. Source-code line attribution combines NVBit's line-info function with nvdisasm-based SASS-to-PTX matching when the former fails. Data-object attribution uses LD_PRELOAD to intercept memory allocation calls and records call stacks, then matches runtime addresses against a tree of allocated regions.
Core claim. Snoopie is a binary-instrumentation-based profiler that fills a gap in multi-GPU communication profiling: it can detect and attribute device-initiated peer-to-peer direct memory accesses (loads/stores from one GPU to another GPU's memory) and communication library calls (NCCL, NVSHMEM) to source code lines and data objects. This is something existing tools cannot do comprehensively. The paper claims that Snoopie's combination of NVBit instrumentation, on-device filtering, device attribution via UVA memory ranges, and SASS-to-PTX matching for line info enables a level of visibility into inter-GPU data movement that was previously unavailable.
The premise it rests on. NVBit can reliably instrument all relevant GPU instructions and the SASS-to-PTX matching for source line attribution works for a sufficient fraction of instructions to be useful; the paper acknowledges that NVBit fails to extract line info from a significant portion of instructions.
If the paper is right (Pith's inferences, not the authors')
Application developers can use Snoopie to locate communication bottlenecks and bugs in multi-GPU codes that use device-initiated P2P or NCCL/NVSHMEM, which were previously opaque.
The tool enables direct comparison of communication patterns between different parallelization strategies (e.g., data vs. model parallelism in deep learning) at the level of individual data objects and source lines.
Snoopie's visualizations (system, object, code, device views) provide a multi-granularity view that can reveal unexpected communication patterns, such as non-neighbor transfers in a ring algorithm or memory over-allocation.
The overhead reduction techniques (on-device filtering, sampling, log compression) make the tool practical for real applications, with reported slowdowns of 2×–96× depending on the workload and sampling rate.
The open-source release allows the community to extend the tool to multi-node setups and other GPU vendors.
Snoopie's ability to attribute communication to source code lines and data objects could be integrated into continuous integration pipelines to automatically flag unexpected communication patterns or regressions.
The SASS-to-PTX matching approach for line attribution, while acknowledged as imperfect, suggests a general strategy that other binary-instrumentation tools could adopt for GPU code attribution.
The paper's focus on single-node multi-GPU leaves a natural next step: extending to multi-node setups (e.g., NCCL with MPI) would make Snoopie applicable to the majority of distributed training workloads.
The tool's reliance on NVBit ties it to NVIDIA GPUs, but the conceptual approach (instrument memory operations, attribute via UVA-like address spaces, match to objects) could be ported to AMD's ROCm or Intel's oneAPI as those ecosystems develop equivalent instrumentation frameworks.
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
With data movement becoming one of the most expensive bottlenecks in computing, the need for profiling tools to analyze communication becomes crucial for effectively scaling multi-GPU applications. While existing profiling tools including first-party software by GPU vendors are robust and excel at capturing compute operations within a single GPU, support for monitoring GPU-GPU data transfers and calls issued by communication libraries is currently inadequate. To fill these gaps, we introduce Snoopie, an instrumentation-based multi-GPU communication profiling tool built on NVBit, capable of tracking peer-to-peer transfers and GPU-centric communication library calls. To increase programmer productivity, Snoopie can attribute data movement to the source code line and the data objects involved. It comes with multiple visualization modes at varying granularities, from a coarse view of the data movement in the system as a whole to specific instructions and addresses. Our case studies demonstrate Snoopie's effectiveness in monitoring data movement, locating performance bugs in applications, and understanding concrete data transfers abstracted beneath communication libraries. The tool is publicly available at https://github.com/ParCoreLab/snoopie.
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
“Our case studies demonstrate Snoopie's effectiveness in monitoring data movement, locating performance bugs in applications, and understanding concrete data transfers abstracted beneath communication libraries.”
How the main claim is stated: asserted 1.00
What the abstract itself states, as probabilities: claims first 0.08 · states limitation 0.10 · human participants 0.03 · controlled comparison 0.06 · randomized assignment 0.01 · states quantitative result 0.04 · compares with prior results 0.62 · mentions code or data availability 0.98
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 |
|---|---|---|---|---|
| With data movement becoming one of the most expensive bottlenecks in computing, the need for profiling tools to analyze communication becomes crucial for effectively scaling multi-GPU applications. | background 1.00 | 0.05 | 0.06 | asserted 1.00 |
| While existing profiling tools including first-party software by GPU vendors are robust and excel at capturing compute operations within a single GPU, support for monitoring GPU-GPU data transfers and calls issued by communication libraries is currently inadequate. | gap 0.99 | 0.07 | 0.04 | asserted 1.00 |
| To fill these gaps, we introduce Snoopie, an instrumentation-based multi-GPU communication profiling tool built on NVBit, capable of tracking peer-to-peer transfers and GPU-centric communication library calls. | contribution 0.97 | 0.89 | 0.17 | asserted 1.00 |
| To increase programmer productivity, Snoopie can attribute data movement to the source code line and the data objects involved. | contribution 0.88 | 0.79 | 0.06 | asserted 0.96 |
| It comes with multiple visualization modes at varying granularities, from a coarse view of the data movement in the system as a whole to specific instructions and addresses. | contribution 0.78 | 0.79 | 0.05 | asserted 1.00 |
| Our case studies demonstrate Snoopie's effectiveness in monitoring data movement, locating performance bugs in applications, and understanding concrete data transfers abstracted beneath communication libraries. | result 0.94 | 0.95 | 0.68 | asserted 1.00 |
| The tool is publicly available at https://github.com/ParCoreLab/snoopie. | contribution 0.80 | 0.24 | 0.02 | asserted 0.99 |
What kind of paper the classifier reports this is: method or tool 1.00 · evidence from observation or experiment 0.99
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, 5,598 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 (12)
Showing 10 of the paper's 12 figures. Figures are the authors', reproduced from the paper.
References (70)
- [1] L. Adhianto, S. Banerjee, M. Fagan, M. Krentel, G. Marin, J. Mellor- Crummey, and N. R. Tallent. 2010. HPCTOOLKIT: Tools for Perfor- mance Analysis of Optimized Parallel Programs Http://Hpctoolkit.Org. Concurr. Comput. : Pract. Exper.22, 6 (apr 2010), 685–701 on Pith
- [2] Inc Advanced Micro Devices. 2024. AMD ROCm Documentation. https://rocm.docs.amd.com/ on Pith
- [3] Inc Advanced Micro Devices. 2024. Omnitrace. https://github.com/ AMDResearch/omnitrace on Pith
- [4] Inc Advanced Micro Devices. 2024. ROCm RCCL Documentation. https://rocm.docs.amd.com/projects/rccl/en/latest/ on Pith
- [5] Inc Advanced Micro Devices. 2024. ROCSHMEM. https://github.com/ ROCm-DeveloperTools/ROC_SHMEM on Pith
- [6] Elena Agostini, Davide Rossetti, and Sreeram Potluri. 2017. Offloading Communication Control Logic in GPU Accelerated Applications. In Proceedings of the 17th IEEE/ACM Int’l Symposium on Cluster, Cloud and Grid Computing (CCGrid’17). IEEE, New York, NY, USA, 248–257. doi:10.11... on Pithdoi:10.1109/ccgrid.2017.29
- [7] Meta AI. 2024. PyTorch. https://github.com/pytorch/pytorch on Pith
- [8] Palwisha Akhtar, Erhan Tezcan, Fareed Mohammad Qararyah, and Didem Unat. 2020. ComScribe: Identifying Intra-Node GPU Commu- nication. InBenchmarking, Measuring, and Optimizing: Third Bench- Council International Symposium, Bench’20. Springer-Verlag, Berlin, Heidelberg, 157–174... on Pithdoi:10.1007/978-3-030-71058-3_10
- [9] Continuum Analytics. 2024. A Just-In-Time Compiler for Numerical Functions in Python. https://github.com/numba/numba on Pith
- [10] Google Brain. 2024. TensorFlow. https://github.com/tensorflow/ tensorflow on Pith
- [11] U.V. Catalyurek and C. Aykanat. 1999. Hypergraph-partitioning-based decomposition for parallel sparse-matrix vector multiplication.IEEE Transactions on Parallel and Distributed Systems10, 7 (1999), 673–693. doi:10.1109/71.780863 on Pithdoi:10.1109/71.780863
- [12] Barcelona Supercomputing Center. [n. d.]. BSC-Performance-Tools: Extrae. https://tools.bsc.es/extrae on Pith
- [13] Yuxin Chen, Benjamin Brock, Serban Porumbescu, Aydın Buluç, Katherine Yelick, and John D. Owens. 2022. Scalable Irregular Paral- lelism with GPUs: Getting CPUs out of the Way. InProceedings of the International Conference on High Performance Computing, Networking, Storage and ... on Pith
- [14] Jürgen Cito, Philipp Leitner, Martin Rinard, and Harald C. Gall. 2019. Interactive Production Performance Feedback in the IDE. In2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). 971–981. doi:10.1109/ICSE.2019.00102 on Pithdoi:10.1109/icse.2019.00102
- [15] Departament Computadors, Vincent Pillet, Jesús Labarta, Toni Cortes, and Sergi Girona. 1995. PARAVER: A tool to visualize and analyze parallel code.WoTUG-1844 (03 1995) on Pith
- [16] Bas Cornelissen, Danny Holten, Andy Zaidman, Leon Moonen, Jarke J. van Wijk, and Arie van Deursen. 2007. Understanding Execution Traces Using Massive Sequence and Circular Bundle Views. In15th IEEE International Conference on Program Comprehension (ICPC ’07). 49–58. doi:10.110... on Pithdoi:10.1109/icpc.2007.39
- [17] Jack J. Dongarra. 2022. The Evolution of Mathematical Software. Commun. ACM65, 12 (Nov 2022), 66–72. doi:10.1145/3554977 on Pithdoi:10.1145/3554977
- [18] Apache Software Foundation. 2024. Apache MXNet for Deep Learning. https://github.com/apache/mxnet on Pith
- [19] Python Software Foundation. 2024. Python/C API Reference Manual. https://docs.python.org/3/c-api/index.html on Pith
- [20] Al Geist, Adam Beguelin, Jack Dongarra, Weicheng Jiang, Robert Manchek, and Vaidy Sunderam. 1995. Pvm 3 User’s Guide And Refer- ence Manual. (11 1995) on Pith
show 50 more
- [21] Sergi Girona, Toni Cortes, and Vincent Pillet. 1994. Effect of Short Term Scheduling on Message Passing Multiprogrammed Systems. (11 1994) on Pith
- [22] Kshitij Gupta, Jeff A. Stuart, and John D. Owens. 2012. A study of Persistent Threads style GPU programming for GPGPU workloads. In 2012 Innovative Parallel Computing (InPar). Institute for Electrical and Electronics Engineers, New York, NY, USA, 1–14. doi:10.1109/InPar. 2012.6339596 on Pithdoi:10.1109/inpar
- [23] Khaled Hamidouche and Michael LeBeane. 2020. GPU INitiated OPen- SHMEM: Correct and Efficient Intra-Kernel Networking for DGPUs. InProceedings of the 25th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming(San Diego, California)(PPoPP ’20). ACM, New York,... on Pithdoi:10.1145/3332466.3374544
- [24] Khaled Hamidouche, Akshay Venkatesh, Ammar Ahmad Awan, Hari Subramoni, Ching-Hsiang Chu, and Dhabaleswar K. Panda. 2015. Ex- ploiting GPUDirect RDMA in Designing High Performance Open- SHMEM for NVIDIA GPU Clusters. In2015 IEEE International Con- ference on Cluster Computing. ... on Pithdoi:10.1109/cluster.2015.21
- [25] K.A. Huck and A.D. Malony. 2005. PerfExplorer: A Performance Data Mining Framework For Large-Scale Parallel Computing. InSC ’05: Proceedings of the 2005 ACM/IEEE Conference on Supercomputing. 41– on Pith
- [26] K.A. Huck, A.D. Malony, R. Bell, and A. Morris. 2005. Design and implementation of a parallel performance data management frame- work. In2005 International Conference on Parallel Processing (ICPP’05). 473–482. doi:10.1109/ICPP.2005.29 on Pithdoi:10.1109/icpp.2005.29
- [27] Ismayil Ismayilov, Javid Baydamirli, Doğan Sağbili, Mohamed Wahib, and Didem Unat. 2023. Multi-GPU Communication Schemes for Itera- tive Solvers: When CPUs Are Not in Charge. InProceedings of the 37th International Conference on Supercomputing(Orlando, FL, USA)(ICS ’23). ACM, ... on Pithdoi:10.1145/3577193.3593713
- [28] Mohammad Kefah Taha Issa, Didem Unat, Dogan Sagbili, Muham- mad Aditya Sasongko, Ilyas Turimbetov, and Javid Baydamirli. 2024. Snoopie Figures. doi:10.6084/m9.figshare.c.7190766.v1 on Pithdoi:10.6084/m9.figshare.c.7190766.v1
- [29] Wenzel Jakob. 2024. pybind11 — Seamless operability between C++11 and Python. https://github.com/pybind/pybind11 on Pith
- [30] George Karypis and Vipin Kumar. 1998. A Fast and High Quality Multi- level Scheme for Partitioning Irregular Graphs.SIAM Journal on Scien- tific Computing20, 1 (1998), 359–392. doi:10.1137/S1064827595287997 on Pithdoi:10.1137/s1064827595287997
- [31] Andreas Knüpfer, Christian Rössel, Dieter an Mey, Scott Biersdorff, Kai Diethelm, Dominic Eschweiler, Markus Geimer, Michael Gerndt, Daniel Lorenz, Allen Malony, Wolfgang E. Nagel, Yury Oleynik, Pe- ter Philippen, Pavel Saviankou, Dirk Schmidl, Sameer Shende, Ronny Tschüter, M... on Pith
- [32] Pouya Kousha, Bharath Ramesh, Kaushik Kandadi Suresh, Ching- Hsiang Chu, Arpan Jain, Nick Sarkauskas, Hari Subramoni, and Dha- baleswar K. Panda. 2019. Designing a Profiling and Visualization Tool for Scalable and In-depth Analysis of High-Performance GPU Clusters. In2019 IEEE... on Pithdoi:10.1109/hipc.2019.00022
- [33] Michael LeBeane, Khaled Hamidouche, Brad Benton, Mauricio Bre- ternitz, Steven K. Reinhardt, and Lizy K. John. 2017. GPU Triggered Networking for Intra-Kernel Communications. InProceedings of the International Conference for High Performance Computing, Networking, Storage and ... on Pithdoi:10.1145/3126908.3126950
- [34] Ang Li, Shuaiwen Leon Song, Jieyang Chen, Xu Liu, Nathan Tal- lent, and Kevin Barker. 2018. Tartan: Evaluating Modern GPU In- terconnect via a Multi-GPU Benchmark Suite. In2018 IEEE Inter- national Symposium on Workload Characterization (IISWC). 191–202. doi:10.1109/IISWC.2018.8573483 on Pithdoi:10.1109/iiswc.2018.8573483
- [35] Mao Lin, Keren Zhou, and Pengfei Su. 2023. DrGPUM: Guiding Mem- ory Optimization for GPU-Accelerated Applications. InProceedings of the 28th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 3(Vancou- ver, BC, Canada)... on Pithdoi:10.1145/3582016.3582044
- [36] Amrita Mathuriya, Deborah Bard, Peter Mendygral, Lawrence Mead- ows, James Arnemann, Lei Shao, Siyu He, Tuomas Kärnä, Diana Moise, Simon J. Pennycook, Kristyn Maschhoff, Jason Sewall, Nalini Kumar, Shirley Ho, Michael F. Ringenburg, Prabhat, and Victor Lee. 2019. CosmoFlow: us... on Pith
- [37] John McCalpin. 2016. STREAM: Sustainable Memory Bandwidth in High Performance Computers. HPCWire https://www.hpcwire.com/ 2016/11/07/mccalpin-traces-hpc-system-balance-trends. 13 ICS ’24, June 4–7, 2024, Kyoto, Japan Issa et al on Pith
- [38] Wolfgang Nagel, Alfred Arnold, Michael Weber, Hans-Christian Hoppe, and Karl Solchenbach. 1996. VAMPIR: Visualization and analysis of mpi resources.Supercomputer12 (05 1996) on Pith
- [39] Greg Nakhimovsky. 2001. Debugging and Performance Tuning with Library Interposers. http://dsc.sun.com/solaris/articles/lib_interposers. html on Pith
- [40] NVIDIA. 2022. Compute Sanitizer. https://docs.nvidia.com/cuda/ compute-sanitizer/ on Pith
- [41] doi:10.1109/SC.2005.55 on Pithdoi:10.1109/sc.2005.55
- [42] NVIDIA. 2022. Multi GPU Programming Models NVSH- MEM. https://github.com/NVIDIA/multi-gpu-programming- models/tree/master/nvshmem_opt on Pith
- [43] NVIDIA. 2022. Multi GPU Programming Models P2P. https://github.com/NVIDIA/multi-gpu-programming-models/ tree/master/multi_threaded_p2p on Pith
- [44] NVIDIA. 2022. NCCL Tests. https://github.com/NVIDIA/nccl-tests on Pith
- [45] NVIDIA. 2022. Nvidia OpenSHMEM Library (NVSHMEM) documen- tation. https://docs.nvidia.com/nvshmem/api/ on Pith
- [46] NVIDIA. 2023. CUDA Binary Utilities. https://docs.nvidia.com/cuda/ cuda-binary-utilities/index.html on Pith
- [47] NVIDIA. 2023. CUPTI. https://docs.nvidia.com/cupti/ on Pith
- [48] NVIDIA. 2023. NVIDIA CUDA Profiling Tools Interface (CUPTI) - CUDA Toolkit. https://developer.nvidia.com/cupti on Pith
- [49] NVIDIA. 2023. NVIDIA Nsight Systems. https://developer.nvidia.com/ nsight-systems on Pith
- [50] NVIDIA. 2023. NVTAGS. https://developer.nvidia.com/nvidia-nvtags on Pith
- [51] NVIDIA. 2023. NVTX. https://docs.nvidia.com/nvtx/ on Pith
- [53] NVIDIA. 2023. Parallel Thread Execution ISA Version 8.2. https: //docs.nvidia.com/cuda/parallel-thread-execution/ on Pith
- [54] Nvidia. 2024. NCCL. https://github.com/NVIDIA/nccl on Pith
- [55] Lena Oden and Holger Fröning. 2013. GGAS: Global GPU address spaces for efficient communication in heterogeneous clusters. In2013 IEEE Int’l Conference on Cluster Computing (CLUSTER). IEEE, Indi- anapolis, IN, USA, 1–8. doi:10.1109/CLUSTER.2013.6702638 on Pithdoi:10.1109/cluster.2013.6702638
- [56] Marc S. Orr, Shuai Che, Bradford M. Beckmann, Mark Oskin, Steven K. Reinhardt, and David A. Wood. 2017. Gravel: Fine-Grain GPU-Initiated Network Messages. InProceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis(Den- ver, C... on Pithdoi:10.1145/3126908.3126914
- [57] Carl Pearson, Abdul Dakkak, Sarah Hashash, Cheng Li, I-Hsin Chung, Jinjun Xiong, and Wen-Mei Hwu. 2019. Evaluating Characteristics of CUDA Communication Primitives on High-Bandwidth Interconnects. InProceedings of the 2019 ACM/SPEC International Conference on Per- formance Eng... on Pithdoi:10.1145/3297663.3310299
- [58] Stephen W. Poole, Oscar Hernandez, Jeffery A. Kuehn, Galen M. Shipman, Anthony Curtis, and Karl Feind. 2011.OpenSHMEM - To- ward a Unified RMA Model. Springer US, Boston, MA, 1379–1391. doi:10.1007/978-0-387-09766-4_490 on Pithdoi:10.1007/978-0-387-09766-4_490
- [59] Sreeram Potluri, Anshuman Goswami, Davide Rossetti, C.J. Newburn, Manjunath Gorentla Venkata, and Neena Imam. 2017. GPU-Centric Communication on NVIDIA GPU Clusters with InfiniBand: A Case Study with OpenSHMEM. In2017 IEEE 24th International Conference on High Performance Comp... on Pithdoi:10.1109/hipc.2017.00037
- [60] Microsoft Research. 2024. deepspeed. https://github.com/microsoft/ DeepSpeed on Pith
- [61] Muhammad Aditya Sasongko, Milind Chabbi, Palwisha Akhtar, and Didem Unat. 2019. ComDetective: a lightweight communication de- tection tool for threads. InProceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (Denver, Color... on Pithdoi:10.1145/3295500.3356214
- [62] Philipp Schaad, Tal Ben-Nun, and Torsten Hoefler. 2022. Boosting Performance Optimization with Interactive Data Movement Visualiza- tion. InProceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis(Dallas, Texas)(SC ’22). IEEE ... on Pith
- [63] Martin Schulz. [n. d.]. MPIT: A New Interface for Performance Tools in MPI 3. http://cscads.rice.edu/2010-08-cscads-mpit.pdf on Pith
- [64] Muhammet Abdullah Soytürk, Palwisha Akhtar, Erhan Tezcan, and Didem Unat. 2022. Monitoring Collective Communication Among GPUs. InEuro-Par 2021: Parallel Processing Workshops, Ricardo Chaves, Dora B. Heras, Aleksandar Ilic, Didem Unat, Rosa M. Badia, Andrea Bracciali, Patrick ... on Pith
- [65] François Trahay, François Rue, Mathieu Faverge, Yutaka Ishikawa, Raymond Namyst, and Jack Dongarra. 2011. EZTrace: A Generic Framework for Performance Analysis. In2011 11th IEEE/ACM Inter- national Symposium on Cluster, Cloud and Grid Computing. 618–619. doi:10.1109/CCGrid.2011.83 on Pithdoi:10.1109/ccgrid.2011.83
- [66] James D. Trotter, Sinan Ekmekçibaşı, Johannes Langguth, Tugba Torun, Emre Düzakın, Aleksandar Ilic, and Didem Unat. 2023. Bringing Order to Sparsity: A Sparse Matrix Reordering Study on Multicore CPUs. InProceedings of the International Conference for High Performance Computin... on Pithdoi:10.1145/3581784
- [67] Didem Unat, Anshu Dubey, Torsten Hoefler, John Shalf, Mark Abraham, Mauro Bianco, Bradford L. Chamberlain, Romain Cledat, H. Carter Edwards, Hal Finkel, Karl Fuerlinger, Frank Hannig, Emmanuel Jean- not, Amir Kamil, Jeff Keasler, Paul H J Kelly, Vitus Leung, Hatem Ltaief, Naoy... on Pithdoi:10.1109/tpds.2017.2703149
- [68] Oreste Villa, Mark Stephenson, David Nellans, and Stephen W. Keck- ler. 2019. NVBit: A Dynamic Binary Instrumentation Framework for NVIDIA GPUs. InProceedings of the 52nd Annual IEEE/ACM Interna- tional Symposium on Microarchitecture(Columbus, OH, USA)(MICRO ’52). ACM, New Yor... on Pithdoi:10.1145/3352460.3358307
- [69] Benjamin Welton and Barton P. Miller. 2019. Diogenes: Looking for an Honest CPU/GPU Performance Measurement Tool. InProceedings of the International Conference for High Performance Computing, Net- working, Storage and Analysis(Denver, Colorado)(SC ’19). ACM, New York, NY, USA,... on Pithdoi:10.1145/3295500.3356213
- [70] Keren Zhou, Yueming Hao, John Mellor-Crummey, Xiaozhu Meng, and Xu Liu. 2020. GVPROF: A Value Profiler for GPU-Based Clusters. InSC20: International Conference for High Performance Computing, Networking, Storage and Analysis. 1–16. doi:10.1109/SC41405.2020. 00093 on PithPith's reviewdoi:10.1109/sc41405.2020
- [71] Keren Zhou, Yueming Hao, John Mellor-Crummey, Xiaozhu Meng, and Xu Liu. 2022. ValueExpert: exploring value patterns in GPU- accelerated applications. InProceedings of the 27th ACM International Conference on Architectural Support for Programming Languages and Operating Systems... on Pithdoi:10.1145/3503222.3507708
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