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...
Saved in:
Published in: | Frontiers in physics 2022-10, Vol.10 |
---|---|
Main Authors: | , |
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 |