Pith. sign in

REVIEW 3 major objections 5 minor 65 references

From Piz Daint to the Stars: Simulation of Stellar Mergers using High-Level Abstractions

T0 review · 3 major / 5 minor · reviewed 2026-08-14 · deepseek-v4-flash

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

Pith's one-line read Octo-Tiger, a stellar-merger simulation built on asynchronous tasks and one-sided remote-memory communication, scales its compute-critical solvers to 2048 GPU nodes at 68.1% parallel efficiency, with the new libfabric backend nearly…

desk verdict A credible AMT-runtime scaling result with a real networking speedup, but the headline 68.1% efficiency covers only the compute kernels, not whole production runs; worth refereeing with requests for fuller data. read the letter →

arxiv 1908.03121 v2 pith:W35AYNBV submitted 2019-08-08 cs.DC cs.CE

Gregor Dai{ss} , Parsa Amini , John Biddiscombe , Patrick Diehl , Juhan Frank , Kevin Huck , Hartmut Kaiser , Dominic Marcello
show 2 more authors
David Pfander Dirk Pflüger
This is my paper · ORCID
classification cs.DCcs.CE
keywords stellarmergersimulationadaptivemeshrefinementfastmultipolemethodasynchronousmany-taskruntimefuturesGPUaccelerationone-sidedcommunicationlibfabric
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

Octo-Tiger, a finite-volume adaptive-mesh-refinement code for binary star mergers, is built entirely on high-level asynchronous abstractions: a task runtime with futures, portable SIMD types, GPU kernels wrapped as stream futures, and a one-sided remote-memory network layer. The paper's central claim is that this design lets an irregular, tree-based application scale to the full size of a GPU-accelerated supercomputer: the compute-critical hydrodynamics and gravity steps achieve 68.1% parallel efficiency at 2048 nodes, and replacing the two-sided MPI messaging backend with a one-sided libfabric backend nearly triples throughput on the largest runs. A sympathetic reader would care because this is evidence that task-based programming models can be a practical route to exascale for difficult, unstructured astrophysics workloads, not just for regular stencil codes.

What carries the argument

The central mechanism is the HPX asynchronous many-task runtime used as a single abstract machine for an octree of sub-grids. Every unit of work is a task: FMM kernel launches on GPUs are wrapped as futures on CUDA streams, and halo exchanges are futures set by remote actions carried by parcels. The paper's key addition is the libfabric parcelport, which replaces two-sided MPI sends and receives with one-sided RMA transfers of pinned halo buffers, polls network completions inside the scheduler loop, and sets the corresponding futures directly, so no thread blocks on communication. This couples fine-grained task scheduling, GPU overlap, and communication into one dependency-driven dataflow.

What would settle it

Run a complete multi-timestep level-17 V1309 simulation at 2048 nodes and 1 node with identical output, measuring wall-clock time including regridding, I/O, and startup; if the resulting efficiency falls clearly below 68% or the libfabric-to-MPI throughput ratio drops well below 3, the headline numbers describe only the compute phase, not the application.

Watch

Extended reading notes

Core claim

The paper reports that Octo-Tiger, running the V1309 Scorpii merger scenario, scales its compute-critical solvers to 2048 nodes of a 5400-node GPU-accelerated supercomputer at 68.1% parallel efficiency, measured as processed sub-grids per second against its own level-14 single-node reference. At the same scales, the new libfabric parcelport, which transfers halo data with one-sided RMA put/get operations and integrates network progress polling into the task scheduler, outperforms the MPI-based parcelport by a factor of almost three. On the node level, the paper shows that the fast multipole gravity kernels can be launched as many small kernels on 128 CUDA streams per GPU, reaching up to 37% of theoretical peak on two V100 GPUs, and that the same source-level abstractions run on CPU-only, KNL, and GPU platforms. Together these results are offered as evidence that a high-level, futurization-based programming model can handle heterogeneity and scale an irregular tree-based adaptive-mesh application to a full system while preserving Octo-Tiger's conservation of linear and angular momentum to machine precision.

Load-bearing premise

Everything rests on the assumption that the throughput metric used for scaling—processed sub-grids per second on the core calculation steps, relative to the code's own single-node baseline—represents the real work of a production simulation; regridding and I/O are excluded from it.

Editorial extensions

If this is right

  • A full 17-level production run of the V1309 merger becomes feasible on current GPU supercomputers, enabling direct comparison between simulated light curves and the 2008 red nova observation.
  • Other tree-based, irregular applications built on the same task runtime can inherit the libfabric speedup without changing application code, since the network layer is a runtime drop-in.
  • The node-level GPU results show that many small, stencil-based kernels on separate CUDA streams can saturate a GPU, offering task-based codes an alternative to work aggregation.
  • Because conservation of linear and angular momentum to machine precision is preserved in the scaled runs, long orbital evolutions can be trusted not to drift from momentum-conservation error.
  • Scaling to 5400 nodes, the largest run, demonstrates that an asynchronous many-task system can hold its own at full machine scale on a heterogeneous platform, not just on homogeneous CPU clusters.

Reading between the lines

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

  • The reported efficiency excludes regridding and I/O, so a natural follow-up is to measure end-to-end timings of a complete simulation; the paper's own startup-timing observation suggests the libfabric gain may be even larger in those phases, but the efficiency metric would need to be recomputed.
  • The same futurization pattern should transfer to other physics modules, such as radiation transport and the hydrodynamics solver itself, once they are ported to GPUs; the paper lists these as future work, so treating them as a near-term outcome is an extension.
  • If the RMA-based parcelport's gains come from one-sided communication rather than libfabric specifically, then MPI libraries offering RMA with an event-driven progress model could capture similar benefits without a new runtime, though the paper notes such an implementation would be more complex.
  • The technique of registering many small kernels as CUDA-stream futures may struggle on GPUs with fewer concurrent streams or with kernels that are much larger, so its generality across GPU generations is an open question.
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.

Referee Report

3 major / 5 minor

Summary. The paper presents Octo-Tiger, an adaptive mesh refinement hydrodynamics and gravity code for stellar merger simulation, and reports its performance on GPU-accelerated HPC systems using the HPX asynchronous many-task runtime. The authors introduce two main technical contributions: a CUDA-futures integration that allows small fast multipole method (FMM) kernels to run concurrently on GPUs inside HPX's task scheduler, and a libfabric-based parcelport for HPX that uses one-sided remote memory access. They provide node-level FMM performance numbers on CPUs, Intel Xeon Phi, and NVIDIA GPUs, and distributed scaling results on Piz Daint up to 5400 nodes. The central claim is that the compute-critical parts (hydrodynamics and gravity) achieve 68.1% parallel efficiency at 2048 nodes for the highest refinement level, and that the libfabric backend outperforms the MPI parcelport by almost a factor of 3 on the largest runs, demonstrating that high-level task-based abstractions can scale an irregular tree-based application to a full supercomputer.

Significance. Should the scaling result hold, it would be a notable demonstration that an asynchronous many-task runtime with one-sided RMA can scale an irregular AMR application to a full GPU-accelerated system, and that a runtime-level networking change (MPI to libfabric) can yield large application-level speedups without changing application code. The paper also provides a useful data point for launching many small GPU kernels inside a task scheduler. Strengths include a direct backend comparison under identical application code, a full-system HPX run on a GPU-accelerated machine, and open-source code with pinned version hashes. The measurements are, however, point estimates from a limited node-hour allocation, and the headline efficiency is computed from an internal throughput metric that excludes non-compute phases such as regridding and I/O.

major comments (3)
  1. [Abstract; Sec. 6.3] The headline claim of 68.1% parallel efficiency at 2048 nodes applies only to the compute-critical halo-exchanging phases; Sec. 6.3 states explicitly that the timing results 'do not include regridding steps or I/O,' and the only full-machine point (level 16 at 5400 nodes) shows 21.2% efficiency. Because the abstract and conclusion claim 'excellent scaling up to the full system on Piz Daint' and 'the viability of the HPX programming model at scale' without this qualification, the central scalability claim is overstated. This is load-bearing: the paper's thesis is that the runtime makes a tree-based application scalable to a full system, and regridding and I/O are recurring, communication-heavy phases in production runs. Please either add whole-run timing measurements that include these phases, or rewrite the abstract and conclusion so that all scalability claims are explicitly restricted to the compute-kernel subset, with a discussion of how the excluded phases are expected to behave.
  2. [Secs. 6.2 and 6.3] The 'efficiency' values cited in the abstract and Sec. 6.3 are not standard parallel efficiencies. Speedup is defined as processed sub-grids per second relative to the level-14 single-node baseline (Sec. 6.2), which mixes weak and strong scaling: the level-17 runs at 2048 nodes operate on about 1.5 million sub-grids, a factor of roughly 140 more than the level-14 baseline, so the 68.1% figure is a throughput ratio normalized by node count, not a measure of how the same problem scales. The term 'parallel efficiency' should be replaced or precisely defined as an application-specific mixed-scaling throughput efficiency; otherwise it is misleading and not comparable to conventional efficiency values in the scaling literature.
  3. [Sec. 6.1.1] The GPU node-level GFLOP/s figures in Table 2 are inferred, not directly measured: the FMM time on the GPU is estimated by subtracting a CPU-only perf-measured non-FMM fraction from the total runtime of the GPU run. This subtraction assumes that the non-FMM time is identical in the two runs, but the paper's own Sec. 6.1.2 describes CPU/GPU kernel-starvation effects that change the CPU's scheduling behavior when GPUs are present. The reported GFLOP/s numbers have no uncertainty quantification, and a direct timing of the GPU execution or a sensitivity analysis of the subtraction assumption should be provided for the node-level performance claims to be fully supported.
minor comments (5)
  1. [Table 2] The entry '459 GFLOPS/s' contains a units typo; it should read '459 GFLOP/s'.
  2. [Fig. 2] The figure is difficult to read because the red and blue lines for the two parcelports at four refinement levels overlap; please use distinct markers and an explicit legend.
  3. [Sec. 2] The phrase 'task-based FFM implementations' contains a typo; it should be 'FMM'.
  4. [Sec. 6.3] The statement that including regridding and I/O 'would further illustrate the effectiveness of the networking layer' is speculative because no such data are shown; please phrase this as an expectation or provide the measurements.
  5. [Sec. 6.2] The paper does not state how many times each configuration was run; please state whether the speedup and efficiency numbers are single-run point estimates and, if possible, add error bars or a brief note on variability.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the scaling and speedup results are direct measurements, and the momentum-conservation claim rests on an externally published prior algorithm.

full rationale

The paper's central claims are empirical performance measurements, not derived predictions. The 68.1% parallel-efficiency figure is defined as the ratio of processed sub-grids per second at 2048 nodes to the measured single-node level-14 rate (Sec. 6.2: 'the speedup is calculated with respect to the number of processed sub-grids per second on one node at level 14'); numerator and denominator are independent timings, so this is a standard normalization choice rather than a fitted input or an output defined by its own input. The libfabric-vs-MPI speedup (Fig. 3 and Sec. 6.3) is likewise a direct throughput comparison between two communication backends, not a derivation from an assumed result. The only self-referential element is the assertion that Octo-Tiger is unique in conserving both linear and angular momentum to machine precision, supported by citations to the authors' prior work, Marcello (2017) and Marcello et al. (2016); that claim is secondary to the paper's scaling and networking contributions, and the cited algorithm was published in an external, peer-reviewed venue and is therefore independently falsifiable. The paper's own limitation that the timing results 'do not include regridding steps or I/O' narrows the scope of the scalability claim but does not make the reasoning circular. No step reduces a claimed result to its own input by construction, and no fitted parameter is renamed as a prediction.

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

The central performance claims rest on a handful of measurement choices and baseline definitions (single-node level-14 reference, FLOP counts, excluded regridding/I/O phases) rather than on free physical parameters. None of the assumptions is a fitted target, but several are load-bearing for the exact numbers, and the few-timestep runs mean the load distribution may not represent full merger simulations.

free parameters (2)
  • Reference baseline for parallel efficiency = level 14 on 1 Piz Daint node
    The speedup and efficiency numbers in Fig. 2 and the abstract's 68.1% efficiency are defined relative to the sub-grids-per-second rate of level 14 on a single node; choosing a different baseline would change the reported efficiency.
  • FMM kernel FLOP counts = 12 FLOPs for monopole-monopole, 455 FLOPs for multipole-multipole interactions
    The GFLOP/s and fraction-of-peak calculations in Sec. 6.1 assume these constant per-interaction FLOP counts from [45]; if they are inaccurate, the achieved-performance numbers shift proportionally.
assumptions (5)
  • domain assumption The perf-measured CPU-only fraction of runtime in the gravity solver remains valid when GPUs are added, so the GPU FMM time can be estimated by subtracting the non-FMM portion from total runtime.
    Section 6.1.1 describes this estimation; the GFLOP/s figures for GPU runs depend on this transferability.
  • domain assumption Processed sub-grids per second is a valid proxy for useful work, and AMR refinement multiplies the number of sub-grids by up to 8 per level, making the mixed weak/strong scaling efficiency in Fig. 2 interpretable.
    Section 6.2 defines the speedup this way; the headline efficiency inherits this metric.
  • domain assumption The level-13 restart file and the AMR structure at startup are representative of a production V1309 run even though only a few time-steps were simulated.
    Section 6 and the conclusion note that only a few time-steps were run; the scaling behavior later in the evolution, with more mass loss and regridding, is not measured.
  • domain assumption The initial V1309 Scorpii model from the Self-Consistent Field method with the stated masses and spin-to-orbital angular momentum ratio is a valid starting configuration for the Darwin-instability phase.
    Section 3 sets up the scenario; if the model is dynamically wrong, the load distribution and thus the performance results could differ, though the performance claims would still hold for a similar workload.
  • domain assumption The HPX MPI parcelport used as the baseline is a representative two-sided MPI implementation for this application.
    Section 5.2 argues the gains come from moving from two-sided to one-sided communication; if the MPI backend were poorly tuned, the speedup would not generalize to other MPI-based HPX configurations.

how reviews work

0 comments
Cite this review

Pith. "Pith review of From Piz Daint to the Stars: Simulation of Stellar Mergers using High-Level Abstractions." pith.science (2026). https://pith.science/paper/W35AYNBV

@misc{pith2026190803121,
  author       = {Pith},
  title        = {Pith review of: From Piz Daint to the Stars: Simulation of Stellar Mergers using High-Level Abstractions},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/W35AYNBV}},
  note         = {Machine review of arXiv:1908.03121}
}
read the original abstract

We study the simulation of stellar mergers, which requires complex simulations with high computational demands. We have developed Octo-Tiger, a finite volume grid-based hydrodynamics simulation code with Adaptive Mesh Refinement which is unique in conserving both linear and angular momentum to machine precision. To face the challenge of increasingly complex, diverse, and heterogeneous HPC systems, Octo-Tiger relies on high-level programming abstractions. We use HPX with its futurization capabilities to ensure scalability both between nodes and within, and present first results replacing MPI with libfabric achieving up to a 2.8x speedup. We extend Octo-Tiger to heterogeneous GPU-accelerated supercomputers, demonstrating node-level performance and portability. We show scalability up to full system runs on Piz Daint. For the scenario's maximum resolution, the compute-critical parts (hydrodynamics and gravity) achieve 68.1% parallel efficiency at 2048 nodes.

Figures

Figures reproduced from arXiv: 1908.03121 by the authors.

Figure 1
Figure 1. The Octo-Tiger model of V1309 Scorpii 20 orbits after the simulation begins. V1309 Scorpii is a contact binary that [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Relative speedup with respect to the processed sub [PITH_FULL_IMAGE:figures/full_fig_p010_2.png] view at source ↗
Figure 3
Figure 3. Ratio of processed sub grids per second between [PITH_FULL_IMAGE:figures/full_fig_p010_3.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

65 extracted references · 51 canonical work pages

  1. [1]

    [n. d.]. Red Giant and Main Sequence Binary (V1309 Sco). https: //www.sharcnet.ca/~jnandez/simulations.html. Accessed: 2019- 03-14

    work page 2019

  2. [2]

    [n. d.]. StarSmasher - a Smoothed Particle Hydrodynamics code. https://jalombar.github.io/starsmasher/. Accessed: 2019-03-14

    work page 2019

  3. [3]

    Emmanuel Agullo, Berenger Bramas, Olivier Coulaud, Eric Darve, Matthias Messner, and Toru Takahashi. 2016. Task-based FMM for heterogeneous architectures. Concurrency and Computation: Practice and Experience 28, 9 (2016), 2608–2629

    work page 2016

  4. [4]

    2016.Task-based fast multipole method for clusters of multicore processors

    Emmanuel Agullo, Bérenger Bramas, Olivier Coulaud, Martin Khannouz, and Luka Stanisic. 2016.Task-based fast multipole method for clusters of multicore processors . Ph.D. Dissertation. Inria Bordeaux Sud-Ouest

    work page 2016

  5. [5]

    Cédric Augonnet, Samuel Thibault, Raymond Namyst, and Pierre- André Wacrenier. 2011. StarPU: a unified platform for task scheduling on heterogeneous multicore architectures.Concurrency and Computation: Practice and Experience 23, 2 (2011), 187– 198

    work page 2011

  6. [6]

    Michael Bauer, Sean Treichler, Elliott Slaughter, and Alex Aiken

    work page

  7. [7]

    John Biddiscombe, Thomas Heller, Anton Bikineev, and Hartmut Kaiser. 2017. Zero Copy Serialization using RMA in the Dis- tributed Task-Based HPX runtime. In14th International Con- ference on Applied Computing . IADIS, International Association for Development of the Information Society

    work page 2017

  8. [8]

    Robert D Blumofe, Christopher F Joerg, Bradley C Kuszmaul, Charles E Leiserson, Keith H Randall, and Yuli Zhou. 1996. Cilk: An efficient multithreaded runtime system.Journal of parallel and distributed computing 37, 1 (1996), 55–69

    work page 1996

Show all 65 references
  1. [9]

    George Bosilca, Aurelien Bouteiller, Anthony Danalis, Mathieu Faverge, Thomas Hérault, and Jack J Dongarra. 2013. Parsec: Exploiting heterogeneity to enhance scalability.Computing in Science & Engineering 15, 6 (2013), 36–45

    2013

  2. [10]

    Greg L Bryan, Michael L Norman, Brian W O’Shea, Tom Abel, John H Wise, Matthew J Turk, Daniel R Reynolds, David C Collins, Peng Wang, Samuel W Skillman, et al. 2014. Enzo: An adaptive mesh refinement code for astrophysics.The Astrophysi- cal Journal Supplement Series 211, 2 (2014), 19

    2014

  3. [11]

    Bradford L Chamberlain, David Callahan, and Hans P Zima. 2007. Parallel programmability and the chapel language.The Interna- tional Journal of High Performance Computing Applications 21, 3 (2007), 291–312

    2007

  4. [12]

    Jee Choi, Aparna Chandramowlishwaran, Kamesh Madduri, and Richard Vuduc. 2014. A cpu: Gpu hybrid implementation and model-driven scheduling of the fast multipole method. InProceed- ings of Workshop on General Purpose Processing Using GPUs . ACM, 64

    2014

  5. [13]

    Colella and P

    P. Colella and P. R. Woodward. 1984. The Piecewise Parabolic Method (PPM) for Gas-Dynamical Simulations.J. Comput. Phys. 54 (Sept. 1984), 174–201. https://doi.org/10.1016/0021-9991(84) 90143-8

    1984 doi

  6. [14]

    Leonardo Dagum and Ramesh Menon. 1998. OpenMP: An Industry-Standard API for Shared-Memory Programming.IEEE Comput. Sci. Eng. 5, 1 (Jan. 1998), 46–55. https://doi.org/10. 1109/99.660313

    1998

  7. [15]

    Gregor Daiß. 2018. Octo-Tiger: Binary Star Systems with HPX on Nvidia P100 . Master thesis. Universität Stuttgart

    2018

  8. [16]

    Marius Dan, Stephan Rosswog, James Guillochon, and Enrico Ramirez-Ruiz. 2011. Prelude to A Double Degenerate Merger: The Onset of Mass Transfer and Its Impact on Gravitational Waves and Surface Detonations. Astrophysical Journal (ApJ) 737, 2, art. id 89 (2011). https://doi.org...

    2011 doi

  9. [17]

    de Supinski Michael Klemm

    Bronis R. de Supinski Michael Klemm. 2017.OpenMP Technical Report 6:Version 5.0 Preview 2 . Technical Report. OpenMP Architecture Review Board

    2017

  10. [18]

    Bruno Desprésa and Emmanuel Labourasse. 2015. Angular Momentum Preserving Cell-Centered Lagrangian and Eulerian Schemes on Arbitrary Grids.J. Comput. Phys. 290 (2015), 28–54. https://doi.org/10.1016/j.jcp.2015.02.032 https://dx.doi.org/10. 1016/j.jcp.2015.02.032

    2015 doi

  11. [19]

    Carter Edwards, Christian R

    H. Carter Edwards, Christian R. Trott, and Daniel Sunderland

  12. [20]

    Wesley Even and Joel E. Tohline. 2009. Constructing Syn- chronously Rotating Double White Dwarf Binaries. The As- trophysical Journal Supplement Series 184 (Oct 2009), 248–

    2009

  13. [21]

    Joshua Faber, Jamie Lombardi, and Fred Rasio. 2010. StarCrash: 3-d Evolution of Self-gravitating Fluid Systems. Astrophysics Source Code Library (2010)

    2010

  14. [22]

    J Davison de St Germain, John McCorquodale, Steven G Parker, and Christopher R Johnson. 2000. Uintah: A massively parallel problem solving environment. InProceedings the Ninth Interna- tional Symposium on High-Performance Distributed Computing . IEEE, 33–41

    2000

  15. [23]

    Izumi Hachisu. 1986. A Versatile Method for Obtaining Structures of Rapidly Rotating Stars. II. Three-dimensional Self-consistent Field Method. The Astrophysical Journal Supplement Series 62 (Nov 1986), 461. https://doi.org/10.1086/191148

    1986 doi

  16. [24]

    Thomas Heller, Hartmut Kaiser, Patrick Diehl, Dietmar Fey, and Marc Alexander Schweitzer. 2016. Closing the Performance Gap with Modern C++. InHigh Performance Computing (Lecture Notes in Computer Science) , Michaela Taufer, Bernd Mohr, and Julian M. Kunkel (Eds.), Vol. 9945. ...

    2016

  17. [25]

    Thomas Heller, Hartmut Kaiser, and Klaus Iglberger. 2012. Ap- plication of the ParalleX Execution Model to Stencil-Based Prob- lems. Computer Science - Research and Development 28, 2- 3 (2012), 253–261. https://doi.org/10.1007/s00450-012-0217-1 https://stellar.cct.lsu.edu/pubs...

    2012 doi

  18. [26]

    Thomas Heller, Hartmut Kaiser, Andreas Schäfer, and Dietmar Fey. 2013. Using HPX and LibGeoDecomp for Scaling HPC Applications on Heterogeneous Supercomputers. InProceedings of the ACM/IEEE Workshop on Latest Advances in Scalable Algorithms for Large-Scale Systems (ScalA, SC W...

    2013

  19. [27]

    Thomas Heller, Bryce Adelstein Lelbach, Kevin A Huck, John Biddiscombe, Patricia Grubel, Alice E Koniges, Matthias Kretz, Dominic Marcello, David Pfander, Adrian Serio, Juhan Frank, Geoffrey C Clayton, Dirk Pflüger, David Eder, and Hartmut Kaiser. 2019. Harnessing billions of ...

    2019 doi

  20. [28]

    Hartmut Kaiser, Thomas Heller, Daniel Bourgeois, and Diet- mar Fey. 2015. Higher-level Parallelization for Local and Dis- tributed Asynchronous Task-Based Programming. InFirst Inter- national Workshop on Extreme Scale Programming Models and Middleware. 29–37. https://doi.org/1...

    2015

  21. [29]

    Hartmut Kaiser, Thomas Heller, Bryce Adelstein Lelbach, Adrian Serio, and Dietmar Fey. 2014. HPX: A Task Based Programming Model in a Global Address Space. InProceedings of the Inter- national Conference on Partitioned Global Address Space Pro- gramming Models (PGAS) (art. id ...

    2014

  22. [30]

    Laxmikant V Kale and Sanjeev Krishnan. 1993. CHARM++: a portable concurrent object oriented system based on C++. In OOPSLA, Vol. 93. Citeseer, 91–108

    1993

  23. [31]

    2015.Extending C++ for Explicit Data-Parallel Programming via SIMD Vector Types

    Matthias Kretz. 2015.Extending C++ for Explicit Data-Parallel Programming via SIMD Vector Types . Ph.D. Dissertation. Goethe University Frankfurt. https://doi.org/10.13140/RG.2.1. 2355.4323 http://publikationen.ub.uni-frankfurt.de/frontdoor/ index/index/docId/38415

    2015

  24. [32]

    Alexander Kurganov and Eitan Tadmor. 2000. New High- Resolution Central Schemes for Nonlinear Conservation Laws and Convection-Diffusion Equations. J. Comput. Phys. 160, 1 (2000), 241–282. https://doi.org/10.1006/jcph.2000.6459 https: //dx.doi.org/10.1006/jcph.2000.6459

    2000

  25. [33]

    Hatem Ltaief and Rio Yokota. 2014. Data-driven execution of fast multipole methods. Concurrency and Computation: Practice and Experience 26, 11 (2014), 1935–1946

    2014

  26. [34]

    Ostriker, and James M

    Morgan MacLeod, Eve C. Ostriker, and James M. Stone. 2018. Bound Outflows, Unbound Ejecta, and the Shaping of Bipolar Remnants during Stellar Coalescence.The Astrophysical Journal 868, 2 (dec 2018), 136. https://doi.org/10.3847/1538-4357/aae9eb

    2018 doi

  27. [35]

    Ostriker, and James M

    Morgan MacLeod, Eve C. Ostriker, and James M. Stone. 2018. Runaway Coalescence at the Onset of Common Envelope Episodes. The Astrophysical Journal 863, 1 (aug 2018), 5. https://doi.org/ 10.3847/1538-4357/aacf08

    2018 doi

  28. [36]

    D. C. Marcello. 2017. A Very Fast and Angular Momentum Conserving Tree Code. Astronomical Journal 154, Article 92 (Sept.2017),92pages. https://doi.org/10.3847/1538-3881/aa7b2f arXiv:astro-ph.IM/1706.06989

    2017 arXiv

  29. [37]

    Marcello, Kundan Kadam, Geoffrey C

    Dominic C. Marcello, Kundan Kadam, Geoffrey C. Clayton, Juhan Frank, Hartmut Kaiser, and Patrick M. Motl. 2016. Introducing Octo-tiger/HPX: Simulating Interacting Binaries with Adaptive Mesh Refinement and the Fast Multipole Method. InProceed- ings of the International Confere...

    2016

  30. [38]

    Marcello and Joel E

    Dominic C. Marcello and Joel E. Tohline. 2012. A Numerical Method for Studying Super-Eddington Mass Transfer in Double White Dwarf Binaries.The Astrophysical Journal Supplement Series 199, Article 35 (Apr 2012), 35 pages. https://doi.org/10. 1088/0067-0049/199/2/35 arXiv:astro...

    2012 arXiv

  31. [39]

    E., Preston, G., and Bensby, T

    Mason, E., Diaz, M., Williams, R. E., Preston, G., and Bensby, T. 2010. The peculiar nova V1309 Scorpii/nova Scorpii 2008* - A candidate twin of V838 Monocerotis.A&A 516 (2010), A108. https://doi.org/10.1051/0004-6361/200913610

    2010 doi

  32. [40]

    L. A. Molnar, D. M. Van Noord, K. Kinemuchi, J. P. Smolin- ski, C. E. Alexander, E. M. Cook, B. Jang, H. A. Kobulnicky, C. J. Spedden, and S. D. Steenwyk. 2017. Prediction of a Red Nova Outburst in KIC 9832227.Astrophysical Journal 840, Ar- ticle 1 (May 2017). https://doi.org/...

    2017 arXiv

  33. [41]

    Motl, Joel E

    Patrick M. Motl, Joel E. Tohline, and Juhan Frank. 2002. Nu- merical Methods for the Simulation of Dynamical Mass Transfer in Binaries. The Astrophysical Journal Supplement Series 138, 1 (jan 2002), 121–148. https://doi.org/10.1086/324159

    2002 doi

  34. [42]

    Marc S Orr, Bradford M Beckmann, Steven K Reinhardt, and David A Wood. 2014. Fine-grain task aggregation and coordina- tion on GPUs. ACM SIGARCH Computer Architecture News 42, 3 (2014), 181–192

    2014

  35. [43]

    Ondřej Pejcha, Brian D Metzger, and Kengo Tomida. 2015. Cool and luminous transients from mass-losing binary stars.Monthly Notices of the Royal Astronomical Society 455, 4 (2015), 4351– 4372

    2015

  36. [44]

    Metzger, Jacob G

    Ondrej Pejcha, Brian D. Metzger, Jacob G. Tyles, and Kengo Tomida. 2017. Pre-explosion Spiral Mass Loss of a Binary Star Merger. The Astrophysical Journal 850, 1 (nov 2017), 59. https: //doi.org/10.3847/1538-4357/aa95b9

    2017 doi

  37. [45]

    David Pfander, Gregor Daiß, Dominic Marcello, Hartmut Kaiser, and Dirk Pflüger. 2018. Accelerating Octo-Tiger: Stellar Mergers on Intel Knights Landing with HPX. InProceedings of the Inter- national Workshop on OpenCL (IWOCL ’18) . ACM, New York, NY, USA, Article 19, 8 pages. ...

    2018 doi

  38. [46]

    Howard Pritchard, Evan Harvey, Sung-Eun Choi, James Swaro, and Zachary Tiffany. 2016. The GNI provider layer for OFI libfabric. In Proceedings of Cray User Group Meeting, CUG , Vol. 2016

    2016

  39. [47]

    Sarotsakulchai, S.-B

    T. Sarotsakulchai, S.-B. Qian, B. Soonthornthum, X. Zhou, J. Zhang, D. E. Reichart, J. B. Haislip, V. V. Kouprianov, and S. Poshyachinda. 2018. TY Pup: A Low-mass-ratio and Deep Contact Binary as a Progenitor Candidate of Luminous Red Novae. Journal of Astrophysics 156, Articl...

    2018 arXiv

  40. [48]

    Aaron Skinner and Eve C

    M. Aaron Skinner and Eve C. Ostriker. 2013. A Two-moment Ra- diation Hydrodynamics Module in Athena Using a Time-explicit Godunov Method. The Astrophysical Journal Supplement Series 206, Article 21 (Jun 2013), 21 pages. https://doi.org/10.1088/ 0067-0049/206/2/21 arXiv:astro-p...

    2013 arXiv

  41. [49]

    Q. J. Socia, W. F. Welsh, D. R. Short, J. A. Orosz, R. J. Angione, G. Windmiller, D. A. Caldwell, and N. M. Batalha. 2018. KIC 9832227: Using Vulcan Data to Negate the 2022 Red Nova Merger Prediction. Astrophysical Journal Letters 864, Article L32 (Sept. 2018), L32 pages. http...

    2018 arXiv

  42. [50]

    St¸ epień

    K. St¸ epień. 2011. Evolution of the progenitor binary of V1309 Scorpii before merger. A&A 531, Article A18 (Jul 2011), A18 pages. https://doi.org/10.1051/0004-6361/201116689 arXiv:astro-ph.SR/1105.2627

    2011 arXiv

  43. [51]

    STE||AR Group. 2017. HPX GitHub repository. https://github. com/STEllAR-GROUP/hpx. Available under the Boost Software License 1.0 (a BSD-style open source license)

    2017

  44. [52]

    STE||AR Group. 2017. OctoTiger AMR Framework GitHub repos- itory. https://github.com/STEllAR-GROUP/octotiger. Available under the Boost Software License 1.0 (a BSD-style open source license)

    2017

  45. [53]

    James M Stone, Thomas A Gardiner, Peter Teuben, John F Hawley, and Jacob B Simon. 2008. Athena: a new code for astrophysical MHD. The Astrophysical Journal Supplement Series 178, 1 (2008), 137

    2008

  46. [54]

    New" or

    Stone, James M. and Gardiner, Thomas A. and Teuben, Pe- ter. 2000. Athena++ radiation GRMHD code. https:// princetonuniversity.github.io/Athena-Cversion/. Available under the BSD 3-Clause "New" or "Revised" License

    2000

  47. [55]

    New" or

    Stone, James M. and Tomida, Kengo and White, Christopher and Felker, Kyle Gerard. 2016. Athena++ radiation GRMHD code. http://princetonuniversity.github.io/athena/. Available under the BSD 3-Clause "New" or "Revised" License

    2016

  48. [56]

    Tasker, Riccardo Brunino, Nigel L

    Elizabeth J. Tasker, Riccardo Brunino, Nigel L. Mitchell, Dolf Michielsen, Stephen Hopton, Frazer R. Pearce, Greg L. Bryan, and Tom Theuns. 2008. A test suite for quantitative com- parison of hydrodynamic codes in astrophysics. Monthly No- tices of the Royal Astronomical Socie...

    2008

  49. [57]

    Peter Thoman, Kiril Dichev, Thomas Heller, Roman Iakymchuk, Xavier Aguilar, Khalid Hasanov, Philipp Gschwandtner, Pierre Lemarinier, Stefano Markidis, Herbert Jordan, et al. 2018. A taxonomy of task-based parallel programming technologies for high-performance computing. The Jo...

    2018

  50. [58]

    Tylenda, M

    R. Tylenda, M. Hajduk, T. Kamiński, A. Udalski, I. Soszyński, M. K. Szymański, M. Kubiak, G. Pietrzyński, R. Poleski, Ł. Wyrzykowski, and K. Ulaczyk. 2011. V1309 Scorpii: merger of a contact binary. A&A 528, Article A114 (April 2011), A114 pages. https://doi.org/10.1051/0004-6...

    2011 arXiv

  51. [59]

    Jin Wang, Norm Rubin, Albert Sidelnik, and Sudhakar Yalaman- chili. 2016. Dynamic thread block launch: a lightweight execution mechanism to support irregular applications on GPUs. ACM SIGARCH Computer Architecture News 43, 3 (2016), 528–540

    2016

  52. [60]

    Asim YarKhan, Jakub Kurzak, and Jack Dongarra. 2011. Quark users’ guide: Queueing and runtime for kernels.University of 13 Tennessee Innovative Computing Laboratory Technical Report ICL-UT-11-02 (2011)

    2011

  53. [61]

    Barba, Tetsu Narumi, and Kenji Yasuoka

    Rio Yokota, L.A. Barba, Tetsu Narumi, and Kenji Yasuoka. 2013. Petascale turbulence simulation using a highly parallel fast multi- pole method on GPUs.Computer Physics Communications 184, 3 (2013), 445 – 455. https://doi.org/10.1016/j.cpc.2012.09.011

    2013 doi

  54. [62]

    Bo Zhang. 2014. Asynchronous task scheduling of the fast mul- tipole method using various runtime systems. In2014 Fourth Workshop on Data-Flow Execution Models for Extreme Scale Computing. IEEE, 9–16. 14

    2014

  55. [263]

    https://doi.org/10.1088/0067-0049/184/2/248 arXiv:astro- ph.SR/0908.2116

    arXiv

  56. [2012]

    In SC’12: Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis

    Legion: Expressing locality and independence with logical regions. In SC’12: Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis. IEEE, 1–11

  57. [2014]

    Kokkos: Enabling manycore performance portability through polymorphic memory access patterns. J. Parallel and Distrib. Comput. 74, 12 (2014), 3202 – 3216. https://doi.org/10.1016/ j.jpdc.2014.07.003 Domain-Specific Languages and High-Level Frameworks for High-Performance Computing

    2014

Pith tools

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