High-Performance Resilient Multi-GPU Hybrid Particle-in-Cell Monte Carlo Simulations at Scale

Ales Podolnik; Allen D. Malony; David Tskhakaya; Erwin Laure; Evangelos Gkolantas; Frank Jenko; Jakub Hromadka; Jeremy J. Williams; Jordy Trilaksono; Kallia Chronaki

REVIEW 4 major objections 6 minor 1 cited by

High-Performance Resilient Multi-GPU Hybrid Particle-in-Cell Monte Carlo Simulations at Scale

T0 review · 4 major / 6 minor · reviewed 2026-08-02 · deepseek-v4-flash

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

Pith's one-line read A hybrid PIC-MC plasma code reaches 800 GPUs with 88% parallel efficiency.

desk verdict Solid engineering integration, but the weak-scaling and resilience claims need more evidence — a revision with methodology detail would make it a strong paper. read the letter →

arxiv 2606.28534 v2 pith:ATL5ZKXB submitted 2026-06-26 physics.plasm-ph cs.DCcs.PFphysics.comp-ph

Jeremy J. Williams , Stefan Costea , David Tskhakaya , Leon Kos , Ales Podolnik , Jakub Hromadka , Jordy Trilaksono , Yi Ju

show 8 more authors

Kallia Chronaki Evangelos Gkolantas Vassilis Papaefstathiou Allen D. Malony Sameer Shende Frank Jenko Erwin Laure Stefano Markidis

This is my paper · ORCID

classification physics.plasm-phcs.DCcs.PFphysics.comp-ph PACS 52.65.Rr52.65.-y

keywords particle-in-cellMonteCarloplasmasimulationGPUscalingcheckpoint/restartloadbalancingopenPMDADIOS2

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

This paper tries to show that adding particle load balancing and checkpoint/restart through a standardized I/O layer to a hybrid MPI+OpenMP GPU port of the BIT1 particle-in-cell Monte Carlo code makes large-scale plasma simulations both faster and resilient. The additions, built on openPMD with ADIOS2 BP4 and SST backends, are claimed to improve strong and weak scaling under heavy I/O and checkpointing workloads. A sympathetic reader would care because fusion edge simulations like divertor sheath runs need long, uninterrupted executions on exascale machines, where load imbalance and node failures are routine. The headline evidence is a 9.13x strong-scaling speedup and 88.0% parallel efficiency at 100 nodes (800 GPUs) on Frontier, achieved with the SST streaming backend combined with particle load balancing. If correct, this provides a practical path for production PIC MC simulations at exascale scale.

What carries the argument

The central object is the hybrid MPI+OpenMP BIT1 code extended with two interacting mechanisms: particle load balancing (PLB), which redistributes particles across MPI ranks so each rank gets a variable cell interval computed before parameterization and memory allocation, and checkpoint/restart (C/R), which stores per-species particle meshes to openPMD iterations using ADIOS2. The I/O layer is the unifying mechanism: ADIOS2 BP4 provides high-throughput file-based checkpointing, while SST streams data in memory for in-situ analysis, and openPMD gives a portable metadata standard. PLB and C/R operate through the same openPMD read/write path, so 'seamless continuation from checkpoints' and 'res

What would settle it

Run the same strong and weak scaling tests on the non-uniform-load sheath case (the one with a left-side plasma source) at 100 nodes on Frontier, repeating each configuration 3-5 times, and inject a real node failure mid-run to test recovery. If parallel efficiency drops substantially below 88% or recovery is not clean, the central scaling claim fails.

Watch

Extended reading notes

Core claim

On its own terms, the central claim is that integrating scalable particle load balancing (PLB) and checkpoint/restart (C/R), unified through openPMD and ADIOS2 with BP4 for file-based checkpointing and SST for in-memory streaming, into the hybrid MPI+OpenMP multi-GPU BIT1 code delivers strong and weak scaling to 800 GPUs that the serial-I/O version cannot match. The strongest formulation: with the ADIOS2 SST backend plus particle load balancing, the code achieved a 9.13x speedup in strong scaling from 10 to 100 nodes and 88.0% parallel efficiency in weak scaling at 100 nodes on Frontier, all while performing frequent diagnostics and checkpointing. The paper also reports a 14.23x speedup over

Load-bearing premise

The headline scaling numbers come from a single uniform-load sheath configuration with one measurement per configuration, so if that proxy does not match real non-uniform workload behavior or run-to-run variance is large, the 88% parallel-efficiency figure will not generalize.

Editorial extensions

If this is right

Production PIC MC runs on exascale machines can maintain high parallel efficiency even with frequent checkpointing and diagnostics, because parallel I/O and streaming replace serial I/O bottlenecks.
The combination of in-memory streaming (SST) and load balancing gives the best scaling of all tested configurations, suggesting that data movement and particle imbalance are the two main killers at scale.
Checkpoint/restart plus load balancing makes long-running divertor sheath simulations practical, allowing runs to resume from a prior state and redistribute work at restart.
The portable OpenMP pinned-memory approach means the same code runs on Nvidia and AMD GPUs without vendor-specific memory management, easing portability to future exascale systems.
In-situ analysis and visualization can piggyback on the checkpoint stream to monitor plasma profiles and per-rank load in real time without stopping the simulation, reducing post-processing overhead.

Reading between the lines

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

The 88% PE figure is reported for a uniform-load sheath proxy; the paper notes production non-uniform loads require much longer equilibration and are shown separately. One testable inference is that if PLB+C/R were applied to the non-uniform 10K-step case at 800 GPUs, the gap in parallel efficiency between SST+PLB and serial I/O would be at least as large as in the uniform case, because imbalance
The resilience validation is 'resume from a previous checkpoint,' not 'inject a failure and recover.' A stronger claim—that BIT1 can survive actual node loss mid-run—would require fault-injection experiments; the current infrastructure appears ready for them.
The 29.19x speedup on MN5 came from a series of optimizations (1D data layout, pinned memory, persistent GPU allocation, asynchronous mover) that are independent of openPMD; the paper's scaling story would apply to any PIC code that adopts the same optimization stack plus the openPMD/ADIOS2 layer, not only to BIT1.
SST's in-memory streaming slightly beats BP4 even in a checkpoint-heavy scenario, hinting that the future of checkpointing on exascale machines may favor staging data in memory or streamed peer-to-peer rather than writing files to disk.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

Colleague,

The paper is a genuine engineering contribution: it integrates particle load balancing, checkpoint/restart, and openPMD/ADIOS2 (BP4 and SST) into the hybrid MPI+OpenMP BIT1 code and reports scaling results up to 800 GPUs on Frontier. The strong scaling data are credible and the baseline comparisons are useful. The profiling work leading to pinned memory and asynchronous execution is a solid, reproducible path for other PIC codes.

The soft spots are in the headline claims. The weak-scaling efficiency numbers in §5.3 are not backed by a description of how the workload was scaled with node count. If the same fixed-size problem was used at every node count, the 'parallel efficiencies' are just normalized strong-scaling times, and the weak-scaling behavior is not demonstrated. With only a single run per configuration, the difference between 80% and 88% PE could be system noise. The resilience claim is also thin: the experiment resumes from an existing checkpoint rather than recovering from an injected failure. And the uniform-load sheath case makes PLB nearly unnecessary, so the 9.13x speedup figure may not transfer to the non-uniform production workloads shown qualitatively in Fig. 6. There is also a concrete inconsistency: Fig. 4's caption says 40K timesteps while Table 2 sets Last_step=10000 for the non-uniform run.

None of these is fatal. The integration is real, and the strong scaling measurements stand on their own. But the paper's two strongest quantitative selling points — 88% weak-scaling PE and the resilience claim — are not yet substantiated with the experiments as described. A revision that states the weak-scaling methodology, adds repeated runs or at least error bars, and tests recovery after an injected node failure would address most of my concerns.

I'd send this to peer review — the work is concrete and the topic matters for exascale PIC — but I would not accept it as is. It's a useful paper for anyone integrating openPMD/ADIOS2 into a particle code or working on GPU load balancing. I'd probably not cite it in my own work, but I'd bring it to a reading group focused on HPC for plasma simulation.

Best,

[Your name]

Referee Report

4 major / 6 minor

Summary. The paper reports extensions to the hybrid MPI+OpenMP BIT1 1D3V particle-in-cell Monte Carlo code: particle load balancing (PLB), checkpoint/restart (C/R), an openPMD/ADIOS2 I/O layer with BP4 and SST backends, and in-situ data analysis and visualization. Performance is evaluated on Dardel, MareNostrum5, LUMI-G, and Frontier, with profiling via Nsight Systems and ROC-Profiler. The headline quantitative results are strong and weak scaling up to 800 GPUs on Frontier: a 9.13x strong-scaling speedup and 88.0% parallel efficiency at 100 nodes when combining SST with PLB, compared with 7.14x and 70.8% for the original serial-I/O GPU version. The experiments are single-run timing comparisons on a uniform-load high-density sheath case, with the non-uniform production load shown only qualitatively. The manuscript is explicitly positioned as a continuation of the authors' prior work [16,17,21,22], and several claimed contributions overlap with those references.

Significance. If the reported scaling and resilience results hold, the framework offers a practical path for large 1D3V PIC-MC simulations on exascale GPU clusters and demonstrates the value of standardized I/O and load balancing for such workloads. Strengths include direct comparisons against explicit baselines across multiple machines, use of the openPMD standard and ADIOS2 engines, and detailed profiling of the development progression from unified memory to pinned and persistent memory. However, the most general claims—weak scaling, fault resilience, and the benefit of PLB on production workloads—are currently under-substantiated because the weak-scaling protocol is undefined, there are no repeated runs or error bars, no failure-injection test is reported, and PLB is evaluated only on a uniform-load proxy. The significance is therefore conditional on the additional experiments and methodological clarification described below.

major comments (4)

[§5.3, Fig. 5] The weak-scaling claim is not verifiable as written. The text reports parallel efficiencies of 70.8% (serial I/O), 76.1% (BP4), 80.0% (BP4+PLB), 83.1% (SST), and 88.0% (SST+PLB) at 100 nodes, but never states how the problem size was increased with node count. Table 3 defines the uniform-load case as 3M cells and approximately 1.2B particles. If this fixed-size problem was used at 10 and 100 nodes, the numbers are strong-scaling time ratios, not weak-scaling efficiencies; the sentence "Despite the increasing workload" is not a protocol. The authors must specify the scaling rule (e.g., cells/GPU and particles/GPU held constant, or some explicit per-node workload) and report the per-node problem sizes. Without this, the headline 88.0% PE does not demonstrate weak scaling to 800 GPUs.
[§5.3, Tables 2–3] All performance conclusions rest on single unreplicated runs. There are no error bars or repeated-run statistics anywhere in §5.3. This matters because the claimed advantages of PLB and SST are modest: SST+PLB gives 88.0% PE versus 83.1% for SST alone and 80.0% for BP4+PLB. With one measurement per configuration, these differences could be system noise. I request either repeated runs reporting the mean and a spread (e.g., min/max or standard deviation), or a revised claim that does not distinguish between configurations whose differences are within expected run-to-run variability.
[§5.2, §5.3] The resilience aspect of the title is not tested. The C/R experiments in §5.3 are described as "initialized from a prior 10K timestep run" and continuing for 2K timesteps; this is a normal restart from an existing checkpoint, not recovery from an injected fault, node loss, or process failure. Section 5.2's 10K non-uniform run also uses periodic checkpointing but no failure is injected. Consequently, "high-performance resilience" overstates what is measured. Add a fault-injection experiment (e.g., kill MPI ranks, simulate node loss, or corrupt a checkpoint) and report recovery overhead and correctness, or restrict the claim to "checkpoint/restart functionality."
[§5.3, §5.4, §4.1] The PLB contribution is validated only on a uniform-load test case where PLB is expected to have little effect. In §5.3, the uniform sheath has 200 particles/cell uniformly; Fig. 5 shows the PLB benefit as a small relative gain. The non-uniform production case is shown qualitatively in Fig. 6 with no runtime or efficiency numbers, yet the abstract and conclusion state PLB is "critical" for non-uniform loads. Further, §4.1 attributes the PLB and C/R implementations to prior papers (Williams et al. [16,17,21,22]); the reader cannot tell which components are new in this manuscript. Please either provide scaling/performance data on a non-uniform load with and without PLB, or clearly delimit the novel additions.

minor comments (6)

[§5.2, Fig. 4] The Fig. 4 caption says "40K timesteps" while the text and Table 2 (Last_step=10000 for the non-uniform run) say 10K. Reconcile and state which value was actually used.
[Table 2] The slash notation in parameter values (e.g., 0/1000, 200/2000, 1/2) is unclear. Specify which value applies to which run and how the two values in the uniform and non-uniform columns relate to specific experiments.
[§5.3, Fig. 5] For the strong-scaling curve, specify the exact node counts used (e.g., 10, 20, 50, 100) and the baseline count used to compute speedup. The figure axes are not described in the text.
[§5.4, Fig. 6] The in-situ visualization section is qualitative. Report the data volume streamed through BP4/SST, the interval between checkpoints, and the overhead of the in-situ analysis on the simulation runtime.
[§4.1] The PLB flag is described as disabled by default. Clarify how load_balance is set in the reported experiments and whether the default is changed in the released version.
[General reproducibility] Include software versions and commit hashes for BIT1, openPMD-api, ADIOS2, compilers, and MPI libraries, as well as OpenMP offload flags. Without these, the portability and performance claims cannot be reproduced or compared across systems.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: claims are direct performance measurements on external HPC systems.

full rationale

This is an empirical systems/performance paper, not a mathematical derivation. Its central claims—strong-scaling speedups (e.g., 9.13x), weak-scaling parallel efficiencies (up to 88.0% PE), I/O backend effects (BP4 vs SST), PLB impact, and checkpoint/restart continuation—are direct measurements on Frontier, MN5, and LUMI-G. There are no fitted parameters, derived quantities, or equations that reduce by construction to the inputs. The self-citations in §4.1 and §5.1–5.2 document prior development steps (parallel I/O, PLB, GPU porting), and the results compare against the authors' own earlier versions as a baseline; this is a normal engineering continuation, not a circular deduction. The acknowledged limitation in §5.3 that a uniform-load case is used because non-uniform equilibration is costly is a generality concern, not circularity. The lack of explicit weak-scaling workload-growth details, single-run timings, and absence of injected-failure tests are verification/correctness limitations, not circular steps. No uniqueness theorem, ansatz, or fitted value is imported from the authors' prior work to force the conclusions. Therefore no significant circularity is present.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

This is an engineering/performance study: no free parameters are fitted to derive results, and no new physical entities are introduced. The load-bearing premises are the representativeness of the benchmark cases, the adequacy of the uniform-load proxy, the standard behavior of the unlisted software/hardware, and the sufficiency of the restart mechanism.

assumptions (4)

domain assumption BIT1's 1D3V electrostatic PIC-MC model is representative of plasma-edge and divertor physics
The scalability and I/O claims are benchmarked only on this model; a higher-dimensional or different collision model may not show the same load-imbalance and I/O behavior (§2, §4.2).
ad hoc to paper The uniform-load high-density sheath case is an adequate proxy for production non-uniform loads
Section 5.3 explicitly switches to uniform load 'due to the considerable time required for non-uniform plasma conditions to reach equilibrium'; the headline scaling results are obtained on this proxy.
domain assumption No assumptions are made about software/hardware versions beyond standard operation
The paper does not list exact CUDA/ROCm, openPMD, or ADIOS2 versions, so the performance results implicitly assume stable, standard operating conditions on Frontier, MN5, LUMI-G, and Dardel.
domain assumption Checkpoint/restart from iteration 0 captures sufficient state for a valid restart
Section 4.1 states iteration 0 captures the latest simulation state, but no numerical-equivalence verification after restart is reported; the restart test is only a continuation from a prior run.

how reviews work

0 comments

Cite this review

Pith. "Pith review of High-Performance Resilient Multi-GPU Hybrid Particle-in-Cell Monte Carlo Simulations at Scale." pith.science (2026). https://pith.science/paper/ATL5ZKXB

@misc{pith2026260628534,
  author       = {Pith},
  title        = {Pith review of: High-Performance Resilient Multi-GPU Hybrid Particle-in-Cell Monte Carlo Simulations at Scale},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ATL5ZKXB}},
  note         = {Machine review of arXiv:2606.28534}
}

read the original abstract

The increasing demand for high-performance computing in plasma physics has driven scalable and resilient simulation methods capable of efficiently exploiting modern multi-GPU architectures. This work extends a portable hybrid MPI+OpenMP implementation of BIT1, focusing on high-performance resilience for accelerated Particle-in-Cell (PIC) Monte Carlo (MC) simulations under both uniform and non-uniform load conditions. Scalable particle load balancing and robust checkpoint/restart mechanisms across Nvidia and AMD accelerators are integrated with standardized I/O using openPMD and ADIOS2. This leverages BP4 for high-performance file-based checkpointing and SST for in-memory data streaming, enabling efficient data movement, resilient large-scale execution, seamless continuation from existing checkpoints, and effective handling of computational and I/O workloads. Advanced HPC profiling and tracing tools, including Nvidia Nsight Systems and AMD ROC-Profiler with Perfetto, provide detailed insights into computation, communication, and system-level behavior for optimization. Performance results on Frontier (OLCF-5), MN5, and LUMI-G demonstrate strong and weak scaling up to 800 GPUs, validating the framework for large-scale PIC MC simulations, while in-situ analysis and visualization using scalable I/O further enhance scientific insight without interrupting multi-GPU execution on current and future exascale systems.

Figures

Figures reproduced from arXiv: 2606.28534 by the authors.

**Figure 1.** Nvidia Nsight Systems OpenMP UM (Left) and PinM (Right) View - GPU Porting of BIT1 Mover Function on MN5 ACC for 3 Timesteps [PITH_FULL_IMAGE:figures/full_fig_p006_1.png] view at source ↗

**Figure 2.** AMD ROC-Profiler (rocprof + Perfetto) OpenMP PinM (HSA and HIP activity) View - GPU Porting of BIT1 Mover Function on Dardel GPU (with corresponding confirmation traces on both LUMI-G and Frontier) for 1 Timestep [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗

**Figure 3.** Hybrid BIT1 (Sheath, Uniform Load) Total Simulation (Development Progression) Strong Scaling on 5 Nodes (20 GPUs) on MN5 ACC for 200 timesteps. As seen in [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: Hybrid BIT1 (Sheath, Non-Uniform Load) Total Simulation on 40 Nodes - Strong Scaling on MN5 GPP / ACC, LUMI-G, and Frontier for 40K timesteps. As shown in [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]

**Figure 5.** Figure 5: Hybrid BIT1 (Sheath, Uniform Load) C/R with PLB Total Simulation (Relative) Speed Up (left) and PE (Right) - Strong and Weak Scaling up to 100 Nodes (up to 800 GPUs) on Frontier for 2K Timesteps. As seen in [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]

**Figure 6.** Figure 6: Performing real-time checkpoint data analysis and visualization using the hybrid BIT1 openPMD BP4/SST (sheath, non-uniform load) simulation on Frontier (with corresponding analysis and visualizations on Dardel GPU, LUMI-G and MN5 ACC), for up to 10K timesteps with 5 C…

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

Computational Methods and GPU Acceleration in Plasma Physics: A Empirical Analysis of arXiv Publications and Research Trends
physics.plasm-ph 2026-08 reject novelty 4.0 of 10

MHD papers have longer abstracts than PIC and gyrokinetic papers in arXiv plasma physics, and PIC papers dominate GPU mentions, based on regressions over 5,522 papers.

Reference graph

Works this paper leans on

22 extracted references · cited by 1 Pith paper

[1]

In: Proceedings of the SC’23 Workshops of the International Conference on High Performance Comput- ing, Network, Storage, and Analysis

Eiling, N., et al.: Checkpoint/Restart for CUDA kernels. In: Proceedings of the SC’23 Workshops of the International Conference on High Performance Comput- ing, Network, Storage, and Analysis. pp. 1729–1737 (2023)

2023
[2]

Fedeli, L., et al.: Pushing the frontier in the design of laser-based electron acceler- ators with groundbreaking mesh-refined Particle-in-Cell simulations on exascale- classsupercomputers.In:SC22:internationalconferenceforhighperformancecom- puting, networking, storage and analysis. pp. 1–12. IEEE (2022)

2022
[3]

https://doi.org/10.5281/zenodo.591699, available at:https://www

Huebl, A., et al.: openPMD: A meta data standard for particle and mesh based data (2015). https://doi.org/10.5281/zenodo.591699, available at:https://www. openPMD.org,https://github.com/openPMD

doi:10.5281/zenodo.591699 2015
[4]

https://doi.org/10.14278/rodare.27, available at:https: //github.com/openPMD/openPMD-api

Huebl, A., et al.: openPMD-api: C++ & Python API for Scientific I/O with openPMD (06 2018). https://doi.org/10.14278/rodare.27, available at:https: //github.com/openPMD/openPMD-api

doi:10.14278/rodare.27 2018
[5]

In: The Exascale applications & Software conference (EASC2016) (2016)

Iakymchuk, R., et al.: A Particle-in-Cell method for automatic load-balancing with the allscale environment. In: The Exascale applications & Software conference (EASC2016) (2016)

2016
[6]

In: 2024 IEEE 31st International Conference on High Per- formance Computing, Data and Analytics Workshop (HiPCW)

Joshi, S., et al.: Combining Checkpoint/Restart and replication for fault tolerance with high performance. In: 2024 IEEE 31st International Conference on High Per- formance Computing, Data and Analytics Workshop (HiPCW). pp. 103–104. IEEE (2024) 12 Jeremy J. Williams et al

2024
[7]

The International Journal of High Performance Computing Applications39(3), 345–363 (2025)

Kemmler, S., et al.: Efficiency and scalability of fully-resolved fluid-particle sim- ulations on heterogeneous CPU-GPU architectures. The International Journal of High Performance Computing Applications39(3), 345–363 (2025)

2025
[8]

The International Journal of High Performance Computing Ap- plications19(2), 143–155 (2005)

Kurzyniec, D., et al.: Failure resilient heterogeneous parallel computing across mul- tidomain clusters. The International Journal of High Performance Computing Ap- plications19(2), 143–155 (2005)

2005

Show all 22 references

[9]

In: International Workshop on OpenMP

Neth, B., et al.: Beyond explicit transfers: shared and managed memory in OpenMP. In: International Workshop on OpenMP. pp. 183–194. Springer (2021)

2021
[10]

In: 2022 IEEE International Parallel and Distributed Processing Symposium (IPDPS)

Qiu, H., et al.: Parallelizing and balancing coupled DSMC/PIC for large-scale par- ticle simulations. In: 2022 IEEE International Parallel and Distributed Processing Symposium (IPDPS). pp. 390–401. IEEE (2022)

2022
[11]

In: 2016 Third Workshop on Accelerator Programming Using Directives (WACCPD)

Sewall, J.D., et al.: A modern memory management system for OpenMP. In: 2016 Third Workshop on Accelerator Programming Using Directives (WACCPD). pp. 25–35. IEEE (2016)

2016
[12]

Journal of Computational Physics225(1), 829–839 (2007)

Tskhakaya, D., et al.: Optimization of PIC codes by improved memory manage- ment. Journal of Computational Physics225(1), 829–839 (2007)

2007
[13]

In: 2010 18thEuromicroConferenceonParallel,DistributedandNetwork-basedProcessing

Tskhakaya, D., et al.: PIC/MC code BIT1 for plasma simulations on HPC. In: 2010 18thEuromicroConferenceonParallel,DistributedandNetwork-basedProcessing. pp. 476–481. IEEE (2010)

2010
[14]

Plasma Sources Science and Technology31(6), 064001 (2022)

Vass, M., et al.: Revisiting the numerical stability/accuracy conditions of explicit PIC/MCC simulations of low-temperature gas discharges. Plasma Sources Science and Technology31(6), 064001 (2022)

2022
[15]

Journal of Computational Physics104(2), 321– 328 (1993)

Verboncoeur, J., et al.: Simultaneous potential and circuit solution for 1D bounded plasma particle simulation codes. Journal of Computational Physics104(2), 321– 328 (1993)

1993
[16]

In: European Con- ference on Parallel Processing

Williams, J.J., et al.: Leveraging HPC Profiling and Tracing Tools to Understand the Performance of Particle-in-Cell Monte Carlo Simulations. In: European Con- ference on Parallel Processing. pp. 123–134. Springer (2023)

2023
[17]

In: 2024 IEEE International Conference on Cluster Computing Workshops (CLUSTER Workshops)

Williams, J.J., et al.: Enabling high-throughput parallel I/O in Particle-In-Cell Monte Carlo simulations with OpenPMD and Darshan I/O monitoring. In: 2024 IEEE International Conference on Cluster Computing Workshops (CLUSTER Workshops). pp. 86–95. IEEE (2024)

2024
[18]

In: International Conference on Com- putational Science

Williams, J.J., et al.: Optimizing BIT1, a Particle-in-Cell Monte Carlo Code, with OpenMP/OpenACC and GPU Acceleration. In: International Conference on Com- putational Science. pp. 316–330. Springer (2024)

2024
[19]

In: European Conference on Parallel Processing

Williams, J.J., et al.: Understanding the Impact of OpenPMD on BIT1, a Particle- in-Cell Monte Carlo Code, Through Instrumentation, Monitoring, and In-Situ Analysis. In: European Conference on Parallel Processing. pp. 214–226. Springer (2024)

2024
[20]

Journal of Computational Science p

Williams, J.J., et al.: Accelerating Particle-in-Cell Monte Carlo simulations with MPI, OpenMP/OpenACC and asynchronous Multi-GPU programming. Journal of Computational Science p. 102590 (2025)

2025
[21]

The International Journal of High Performance Computing Applications (2025)

Williams, J.J., et al.: Integrating High Performance In-Memory Data Streaming and In-Situ Visualization in Hybrid MPI+ OpenMP PIC MC Simulations Towards Exascale. The International Journal of High Performance Computing Applications (2025)

2025
[22]

In: International Conference on Computational Science

Williams, J.J., et al.: Multi-GPU Hybrid Particle-in-Cell Monte Carlo Simulations for Exascale Computing Systems. In: International Conference on Computational Science. pp. 32–47. Springer (2026)

2026

Pith tools

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

[1] [1]

In: Proceedings of the SC’23 Workshops of the International Conference on High Performance Comput- ing, Network, Storage, and Analysis

Eiling, N., et al.: Checkpoint/Restart for CUDA kernels. In: Proceedings of the SC’23 Workshops of the International Conference on High Performance Comput- ing, Network, Storage, and Analysis. pp. 1729–1737 (2023)

2023

[2] [2]

Fedeli, L., et al.: Pushing the frontier in the design of laser-based electron acceler- ators with groundbreaking mesh-refined Particle-in-Cell simulations on exascale- classsupercomputers.In:SC22:internationalconferenceforhighperformancecom- puting, networking, storage and analysis. pp. 1–12. IEEE (2022)

2022

[3] [3]

https://doi.org/10.5281/zenodo.591699, available at:https://www

Huebl, A., et al.: openPMD: A meta data standard for particle and mesh based data (2015). https://doi.org/10.5281/zenodo.591699, available at:https://www. openPMD.org,https://github.com/openPMD

doi:10.5281/zenodo.591699 2015

[4] [4]

https://doi.org/10.14278/rodare.27, available at:https: //github.com/openPMD/openPMD-api

Huebl, A., et al.: openPMD-api: C++ & Python API for Scientific I/O with openPMD (06 2018). https://doi.org/10.14278/rodare.27, available at:https: //github.com/openPMD/openPMD-api

doi:10.14278/rodare.27 2018

[5] [5]

In: The Exascale applications & Software conference (EASC2016) (2016)

Iakymchuk, R., et al.: A Particle-in-Cell method for automatic load-balancing with the allscale environment. In: The Exascale applications & Software conference (EASC2016) (2016)

2016

[6] [6]

In: 2024 IEEE 31st International Conference on High Per- formance Computing, Data and Analytics Workshop (HiPCW)

Joshi, S., et al.: Combining Checkpoint/Restart and replication for fault tolerance with high performance. In: 2024 IEEE 31st International Conference on High Per- formance Computing, Data and Analytics Workshop (HiPCW). pp. 103–104. IEEE (2024) 12 Jeremy J. Williams et al

2024

[7] [7]

The International Journal of High Performance Computing Applications39(3), 345–363 (2025)

Kemmler, S., et al.: Efficiency and scalability of fully-resolved fluid-particle sim- ulations on heterogeneous CPU-GPU architectures. The International Journal of High Performance Computing Applications39(3), 345–363 (2025)

2025

[8] [8]

The International Journal of High Performance Computing Ap- plications19(2), 143–155 (2005)

Kurzyniec, D., et al.: Failure resilient heterogeneous parallel computing across mul- tidomain clusters. The International Journal of High Performance Computing Ap- plications19(2), 143–155 (2005)

2005