Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Skip to main content
Springer Nature Link
Log in

Benchmarking the Parallel 1D Heat Equation Solver in Chapel, Charm++, C++, HPX, Go, Julia, Python, Rust, Swift, and Java

  • Conference paper
  • First Online:
Euro-Par 2023: Parallel Processing Workshops (Euro-Par 2023)

Part of the book series: Lecture Notes in Computer Science ((LNCS,volume 14352))

Included in the following conference series:

Abstract

Many scientific high performance codes that simulate e.g. black holes, coastal waves, climate and weather, etc. rely on block-structured meshes and use finite differencing methods to solve the appropriate systems of differential equations iteratively. This paper investigates implementations of a straightforward simulation of this type using various programming systems and languages. We focus on a shared memory, parallelized algorithm that simulates a 1D heat diffusion using asynchronous queues for the ghost zone exchange. We discuss the advantages of the various platforms and explore the performance of this model code on different computing architectures: Intel, AMD, and ARM64FX. As a result, Python was the slowest of the set we compared. Java, Go, Swift, and Julia were the intermediate performers. The higher performing platforms were C++, Rust, Chapel, Charm++, and HPX.

This is a preview of subscription content, log in via an institution to check access.

Access this chapter

Log in via an institution

Subscribe and save

Springer+ Basic
$34.99 /Month
  • Get 10 units per month
  • Download Article/Chapter or eBook
  • 1 Unit = 1 Article or 1 Chapter
  • Cancel anytime
Subscribe now

Buy Now

Chapter
USD 29.95
Price excludes VAT (USA)
  • Available as PDF
  • Read on any device
  • Instant download
  • Own it forever
eBook
USD 49.99
Price excludes VAT (USA)
  • Available as EPUB and PDF
  • Read on any device
  • Instant download
  • Own it forever
Softcover Book
USD 59.99
Price excludes VAT (USA)
  • Compact, lightweight edition
  • Dispatched in 3 to 5 business days
  • Free shipping worldwide - see info

Tax calculation will be finalised at checkout

Purchases are for personal use only

Institutional subscriptions

Similar content being viewed by others

Notes

  1. 1.

    https://github.com/diehlpk/async_heat_equation.

  2. 2.

    https://lumol.org/.

  3. 3.

    https://github.com/AlDanial/cloc.

  4. 4.

    https://github.com/boyter/scc.

  5. 5.

    https://doi.org/10.1038/s41586-020-2649-2.

  6. 6.

    https://github.com/diehlpk/async_heat_equation.

  7. 7.

    https://hub.docker.com/r/diehlpk/monte-carlo-codes.

References

  1. Amedro, B., et al.: Current state of Java for HPC. Ph.D. thesis, INRIA (2008)

    Google Scholar 

  2. Arnold, K., Gosling, J., Holmes, D.: The Java Programming Language. Addison Wesley Professional, Boston (2005)

    Google Scholar 

  3. Barry, B., et al.: Software engineering economics. New York 197, 140 (1981)

    Google Scholar 

  4. Bennett, J., et al.: ASC ATDM level 2 milestone# 5325: asynchronous many-task runtime system analysis and assessment for next generation platforms. SAND2015-8312 (2015)

    Google Scholar 

  5. Bezanson, J., et al.: Julia: a fresh approach to numerical computing. SIAM Rev. 59(1), 65–98 (2017)

    Article  MathSciNet  Google Scholar 

  6. Chamberlain, B.L., Deitz, S., Hribar, M.B., Wong, W.: Chapel. Programming Models for Parallel Computing, pp. 129–159 (2015)

    Google Scholar 

  7. Chamberlain, B.L., et al.: Parallel programmability and the chapel language. Int. J. High Perform. Comput. Appl. 21(3), 291–312 (2007)

    Article  Google Scholar 

  8. Diehl, P., et al.: Benchmarking the Parallel 1D Heat Equation Solver in Chapel, Charm++, C++, HPX, Go, Julia, Python, Rust, Swift, and Java (2023). https://doi.org/10.5281/zenodo.7942453. https://doi.org/10.5281/zenodo.7942453

  9. Godoy, W.F., et al.: Evaluating performance and portability of high-level programming models: Julia, python/numba, and kokkos on exascale nodes (2023)

    Google Scholar 

  10. Harris, C.R., et al.: Array programming with NumPy. Nature 585(7825), 357–362 (2020)

    Article  Google Scholar 

  11. Kaiser, H., et al.: HPX-the C++ standard library for parallelism and concurrency. J. Open Source Softw. 5(53), 2352 (2020)

    Article  Google Scholar 

  12. Kale, L.V., Krishnan, S.: Charm++ a portable concurrent object oriented system based on C++. In: Proceedings of the Eighth Annual Conference on Object-oriented Programming Systems, Languages, and Applications, pp. 91–108 (1993)

    Google Scholar 

  13. Kepner, J.: High performance computing productivity model synthesis. Int. J. High Perform. Comput. Appl. 18(4), 505–516 (2004)

    Article  Google Scholar 

  14. Kortschak, R.D., et al.: bíogo: a simple high-performance bioinformatics toolkit for the go language. J. Open Source Softw. 2(10), 167 (2017)

    Article  Google Scholar 

  15. Köster, J.: Rust-bio: a fast and safe bioinformatics library. Bioinformatics 32(3), 444–446 (2016)

    Article  Google Scholar 

  16. Matsakis, N.D., Klock II, F.S.: The rust language. In: ACM SIGAda Ada Letters, vol. 34, pp. 103–104. ACM (2014)

    Google Scholar 

  17. Miller, J., et al.: Applicability of the software cost model COCOMO II to HPC projects. Int. J. Comput. Sci. Eng. 17(3), 283–296 (2018)

    Google Scholar 

  18. Pennycook, S.J., et al.: Navigating performance, portability, and productivity. Comput. Sci. Eng. 23(5), 28–38 (2021)

    Article  Google Scholar 

  19. Stutzke, R.D., Crosstalk, M.: Software estimating technology: A survey. Los. Alamitos, CA: IEEE Computer Society Press (1997)

    Google Scholar 

  20. Taboada, G.L., et al.: Java for high performance computing: assessment of current research and practice. In: Proceedings of the 7th International Conference on Principles and Practice of Programming in Java, pp. 30–39 (2009)

    Google Scholar 

  21. Van Rossum, G., Drake, F.L.: Python 3 Reference Manual. CreateSpace, Scotts Valley, CA (2009)

    Google Scholar 

  22. Van der Wijngaart, R.F., et al.: Comparing runtime systems with exascale ambitions using the parallel research kernels. In: Kunkel, J., Balaji, P., Dongarra, J. (eds.) ISC High Performance 2016. LNCS, vol. 9697, pp. 321–339. Springer, Cham (2016). https://doi.org/10.1007/978-3-319-41321-1_17

    Chapter  Google Scholar 

Download references

Acknowledgments

The authors would like to thank Stony Brook Research Computing and Cyberinfrastructure, and the Institute for Advanced Computational Science at Stony Brook University for access to the innovative high-performance Ookami computing system, which was made possible by a $5M National Science Foundation grant (#1927880). We thank Steve Canon and Nick Everitt for their remarks on the Swift code and Brad Chamberlain and Jeremiah Corrado for their remarks on the Chapel code.

Author information

Authors and Affiliations

  1. Center of Computation and Technology, Louisiana State University, Baton Rouge, USA

    Patrick Diehl, Max Morris, Steven R. Brandt & Hartmut Kaiser

  2. Department of Physics and Astronomy, Louisiana State University, Baton Rouge, USA

    Patrick Diehl

  3. Department of Computer Science, Louisiana State University, Baton Rouge, USA

    Hartmut Kaiser

  4. Amazon LLC (Work done before joining Amazon), Seattle, USA

    Nikunj Gupta

Authors
  1. Patrick Diehl
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Max Morris
    View author publications

    You can also search for this author in PubMed Google Scholar

  3. Steven R. Brandt
    View author publications

    You can also search for this author in PubMed Google Scholar

  4. Nikunj Gupta
    View author publications

    You can also search for this author in PubMed Google Scholar

  5. Hartmut Kaiser
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Patrick Diehl .

Editor information

Editors and Affiliations

  1. University of Cyprus, Nicosia, Cyprus

    Demetris Zeinalipour

  2. University of Santiago de Compostela, Santiago de Compostela, Spain

    Dora Blanco Heras

  3. University of Cyprus, Nicosia, Cyprus

    George Pallis

  4. Cyprus University of Technology, Limassol, Cyprus

    Herodotos Herodotou

  5. University of Nicosia, Nicosia, Cyprus

    Demetris Trihinas

  6. Inria, Nantes, France

    Daniel Balouek

  7. Louisiana State University, Baton Rouge, LA, USA

    Patrick Diehl

  8. Karlsruhe Institute of Technology, Karlsruhe, Germany

    Terry Cojean

  9. Ludwig-Maximilians-Universität, Munich, Germany

    Karl Fürlinger

  10. Roskilde University, Roskilde, Denmark

    Maja Hanne Kirkeby

  11. Bank of Italy, Rome, Italy

    Matteo Nardelli

  12. Roma Tre University, Rome, Italy

    Pierangelo Di Sanzo

Rights and permissions

Reprints and permissions

Copyright information

© 2024 The Author(s), under exclusive license to Springer Nature Switzerland AG

About this paper

Check for updates. Verify currency and authenticity via CrossMark

Cite this paper

Diehl, P., Morris, M., Brandt, S.R., Gupta, N., Kaiser, H. (2024). Benchmarking the Parallel 1D Heat Equation Solver in Chapel, Charm++, C++, HPX, Go, Julia, Python, Rust, Swift, and Java. In: Zeinalipour, D., et al. Euro-Par 2023: Parallel Processing Workshops. Euro-Par 2023. Lecture Notes in Computer Science, vol 14352. Springer, Cham. https://doi.org/10.1007/978-3-031-48803-0_11

Download citation

  • DOI: https://doi.org/10.1007/978-3-031-48803-0_11

  • Published:

  • Publisher Name: Springer, Cham

  • Print ISBN: 978-3-031-48802-3

  • Online ISBN: 978-3-031-48803-0

  • eBook Packages: Computer ScienceComputer Science (R0)

Publish with us

Policies and ethics

Search

Navigation