Loading…

Simulating the Euler equations on multiple GPUs using Python

GPUs have become a household name in High Performance Computing (HPC) systems over the last 15 years. However, programming GPUs is still largely a manual and arduous task, which requires expert knowledge of the physics, mathematics, and computer science involved. Even though there have been large ad...

Full description

Saved in:
Bibliographic Details
Published in:Frontiers in physics 2022-10, Vol.10
Main Authors: Brodtkorb, André R., Sætra, Martin L.
Format: Article
Language:English
Subjects:
Citations: Items that this one cites
Online Access:Get full text
Tags: Add Tag
No Tags, Be the first to tag this record!
cited_by
cites cdi_FETCH-LOGICAL-c304t-6b3023ebff6a5c466ab5b92ade0c5c1f589c280a1bc6d1c4e015b7b6cf26cb0f3
container_end_page
container_issue
container_start_page
container_title Frontiers in physics
container_volume 10
creator Brodtkorb, André R.
Sætra, Martin L.
description GPUs have become a household name in High Performance Computing (HPC) systems over the last 15 years. However, programming GPUs is still largely a manual and arduous task, which requires expert knowledge of the physics, mathematics, and computer science involved. Even though there have been large advances in automatic parallelization and GPU execution of serial code, it is still difficult to fully utilize the GPU hardware with such approaches. Many core numeric GPU codes are therefore still mostly written using low level C/C++ or Fortran for the host code. Several studies have shown that using higher level languages, such as Python, can make software development faster and with fewer bugs. We have developed a simulator based on PyCUDA and mpi4py in Python for solving the Euler equations on Cartesian grids. Our framework utilizes the GPU, and can automatically run on clusters using MPI as well as on shared-memory systems. Our framework allows the programmer to implement low-level details in CUDA C/C++, which is important to achieve peak performance, whilst still benefiting from the productivity of Python. We show that our framework achieves good weak and strong scaling. Our weak scaling achieves more than 94% efficiency on a shared-memory GPU system and more than 90% efficiency on a distributed-memory GPU system, and our strong scaling is close to perfect on both shared-memory and distributed-memory GPU systems.
doi_str_mv 10.3389/fphy.2022.985440
format article
fullrecord <record><control><sourceid>doaj_cross</sourceid><recordid>TN_cdi_doaj_primary_oai_doaj_org_article_76e851b2d604423caaa6400ca7056423</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><doaj_id>oai_doaj_org_article_76e851b2d604423caaa6400ca7056423</doaj_id><sourcerecordid>oai_doaj_org_article_76e851b2d604423caaa6400ca7056423</sourcerecordid><originalsourceid>FETCH-LOGICAL-c304t-6b3023ebff6a5c466ab5b92ade0c5c1f589c280a1bc6d1c4e015b7b6cf26cb0f3</originalsourceid><addsrcrecordid>eNpNkE1rAjEQQENpoWK995g_sHby6S70UsRaQajQCr2FJJvoyrqxye7Bf99dLaWnGd4M7_AQeiQwZSwvnvxpf55SoHRa5IJzuEEjSguZccq_bv_t92iS0gEACBVFTvkIPX9Ux67WbdXscLt3eNHVLmL33fUoNAmHBvf3tjrVDi8324S7NLxuzu0-NA_ozus6ucnvHKPt6-Jz_pat35er-cs6swx4m0nDgDJnvJdaWC6lNsIUVJcOrLDEi7ywNAdNjJUlsdwBEWZmpPVUWgOejdHq6i2DPqhTrI46nlXQlbqAEHdKx7aytVMz6XJBDC0lcE6Z1VpLDmD1DITsQe-Cq8vGkFJ0_s9HQA0x1RBTDTHVNSb7AVUBaE8</addsrcrecordid><sourcetype>Open Website</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype></control><display><type>article</type><title>Simulating the Euler equations on multiple GPUs using Python</title><source>ROAD: Directory of Open Access Scholarly Resources</source><creator>Brodtkorb, André R. ; Sætra, Martin L.</creator><creatorcontrib>Brodtkorb, André R. ; Sætra, Martin L.</creatorcontrib><description>GPUs have become a household name in High Performance Computing (HPC) systems over the last 15 years. However, programming GPUs is still largely a manual and arduous task, which requires expert knowledge of the physics, mathematics, and computer science involved. Even though there have been large advances in automatic parallelization and GPU execution of serial code, it is still difficult to fully utilize the GPU hardware with such approaches. Many core numeric GPU codes are therefore still mostly written using low level C/C++ or Fortran for the host code. Several studies have shown that using higher level languages, such as Python, can make software development faster and with fewer bugs. We have developed a simulator based on PyCUDA and mpi4py in Python for solving the Euler equations on Cartesian grids. Our framework utilizes the GPU, and can automatically run on clusters using MPI as well as on shared-memory systems. Our framework allows the programmer to implement low-level details in CUDA C/C++, which is important to achieve peak performance, whilst still benefiting from the productivity of Python. We show that our framework achieves good weak and strong scaling. Our weak scaling achieves more than 94% efficiency on a shared-memory GPU system and more than 90% efficiency on a distributed-memory GPU system, and our strong scaling is close to perfect on both shared-memory and distributed-memory GPU systems.</description><identifier>ISSN: 2296-424X</identifier><identifier>EISSN: 2296-424X</identifier><identifier>DOI: 10.3389/fphy.2022.985440</identifier><language>eng</language><publisher>Frontiers Media S.A</publisher><subject>CFD ; conservation laws ; CUDA ; finite-volume methods ; GPU computing ; Python</subject><ispartof>Frontiers in physics, 2022-10, Vol.10</ispartof><lds50>peer_reviewed</lds50><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed><cites>FETCH-LOGICAL-c304t-6b3023ebff6a5c466ab5b92ade0c5c1f589c280a1bc6d1c4e015b7b6cf26cb0f3</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>314,778,782,27911,27912</link.rule.ids></links><search><creatorcontrib>Brodtkorb, André R.</creatorcontrib><creatorcontrib>Sætra, Martin L.</creatorcontrib><title>Simulating the Euler equations on multiple GPUs using Python</title><title>Frontiers in physics</title><description>GPUs have become a household name in High Performance Computing (HPC) systems over the last 15 years. However, programming GPUs is still largely a manual and arduous task, which requires expert knowledge of the physics, mathematics, and computer science involved. Even though there have been large advances in automatic parallelization and GPU execution of serial code, it is still difficult to fully utilize the GPU hardware with such approaches. Many core numeric GPU codes are therefore still mostly written using low level C/C++ or Fortran for the host code. Several studies have shown that using higher level languages, such as Python, can make software development faster and with fewer bugs. We have developed a simulator based on PyCUDA and mpi4py in Python for solving the Euler equations on Cartesian grids. Our framework utilizes the GPU, and can automatically run on clusters using MPI as well as on shared-memory systems. Our framework allows the programmer to implement low-level details in CUDA C/C++, which is important to achieve peak performance, whilst still benefiting from the productivity of Python. We show that our framework achieves good weak and strong scaling. Our weak scaling achieves more than 94% efficiency on a shared-memory GPU system and more than 90% efficiency on a distributed-memory GPU system, and our strong scaling is close to perfect on both shared-memory and distributed-memory GPU systems.</description><subject>CFD</subject><subject>conservation laws</subject><subject>CUDA</subject><subject>finite-volume methods</subject><subject>GPU computing</subject><subject>Python</subject><issn>2296-424X</issn><issn>2296-424X</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2022</creationdate><recordtype>article</recordtype><sourceid>DOA</sourceid><recordid>eNpNkE1rAjEQQENpoWK995g_sHby6S70UsRaQajQCr2FJJvoyrqxye7Bf99dLaWnGd4M7_AQeiQwZSwvnvxpf55SoHRa5IJzuEEjSguZccq_bv_t92iS0gEACBVFTvkIPX9Ux67WbdXscLt3eNHVLmL33fUoNAmHBvf3tjrVDi8324S7NLxuzu0-NA_ozus6ucnvHKPt6-Jz_pat35er-cs6swx4m0nDgDJnvJdaWC6lNsIUVJcOrLDEi7ywNAdNjJUlsdwBEWZmpPVUWgOejdHq6i2DPqhTrI46nlXQlbqAEHdKx7aytVMz6XJBDC0lcE6Z1VpLDmD1DITsQe-Cq8vGkFJ0_s9HQA0x1RBTDTHVNSb7AVUBaE8</recordid><startdate>20221003</startdate><enddate>20221003</enddate><creator>Brodtkorb, André R.</creator><creator>Sætra, Martin L.</creator><general>Frontiers Media S.A</general><scope>AAYXX</scope><scope>CITATION</scope><scope>DOA</scope></search><sort><creationdate>20221003</creationdate><title>Simulating the Euler equations on multiple GPUs using Python</title><author>Brodtkorb, André R. ; Sætra, Martin L.</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c304t-6b3023ebff6a5c466ab5b92ade0c5c1f589c280a1bc6d1c4e015b7b6cf26cb0f3</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2022</creationdate><topic>CFD</topic><topic>conservation laws</topic><topic>CUDA</topic><topic>finite-volume methods</topic><topic>GPU computing</topic><topic>Python</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Brodtkorb, André R.</creatorcontrib><creatorcontrib>Sætra, Martin L.</creatorcontrib><collection>CrossRef</collection><collection>DOAJ Directory of Open Access Journals</collection><jtitle>Frontiers in physics</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Brodtkorb, André R.</au><au>Sætra, Martin L.</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Simulating the Euler equations on multiple GPUs using Python</atitle><jtitle>Frontiers in physics</jtitle><date>2022-10-03</date><risdate>2022</risdate><volume>10</volume><issn>2296-424X</issn><eissn>2296-424X</eissn><abstract>GPUs have become a household name in High Performance Computing (HPC) systems over the last 15 years. However, programming GPUs is still largely a manual and arduous task, which requires expert knowledge of the physics, mathematics, and computer science involved. Even though there have been large advances in automatic parallelization and GPU execution of serial code, it is still difficult to fully utilize the GPU hardware with such approaches. Many core numeric GPU codes are therefore still mostly written using low level C/C++ or Fortran for the host code. Several studies have shown that using higher level languages, such as Python, can make software development faster and with fewer bugs. We have developed a simulator based on PyCUDA and mpi4py in Python for solving the Euler equations on Cartesian grids. Our framework utilizes the GPU, and can automatically run on clusters using MPI as well as on shared-memory systems. Our framework allows the programmer to implement low-level details in CUDA C/C++, which is important to achieve peak performance, whilst still benefiting from the productivity of Python. We show that our framework achieves good weak and strong scaling. Our weak scaling achieves more than 94% efficiency on a shared-memory GPU system and more than 90% efficiency on a distributed-memory GPU system, and our strong scaling is close to perfect on both shared-memory and distributed-memory GPU systems.</abstract><pub>Frontiers Media S.A</pub><doi>10.3389/fphy.2022.985440</doi><oa>free_for_read</oa></addata></record>
fulltext fulltext
identifier ISSN: 2296-424X
ispartof Frontiers in physics, 2022-10, Vol.10
issn 2296-424X
2296-424X
language eng
recordid cdi_doaj_primary_oai_doaj_org_article_76e851b2d604423caaa6400ca7056423
source ROAD: Directory of Open Access Scholarly Resources
subjects CFD
conservation laws
CUDA
finite-volume methods
GPU computing
Python
title Simulating the Euler equations on multiple GPUs using Python
url http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-15T09%3A43%3A00IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-doaj_cross&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Simulating%20the%20Euler%20equations%20on%20multiple%20GPUs%20using%20Python&rft.jtitle=Frontiers%20in%20physics&rft.au=Brodtkorb,%20Andr%C3%A9%20R.&rft.date=2022-10-03&rft.volume=10&rft.issn=2296-424X&rft.eissn=2296-424X&rft_id=info:doi/10.3389/fphy.2022.985440&rft_dat=%3Cdoaj_cross%3Eoai_doaj_org_article_76e851b2d604423caaa6400ca7056423%3C/doaj_cross%3E%3Cgrp_id%3Ecdi_FETCH-LOGICAL-c304t-6b3023ebff6a5c466ab5b92ade0c5c1f589c280a1bc6d1c4e015b7b6cf26cb0f3%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true