From 6d46adb6a17056966d844081965ef7bb015a8a5f Mon Sep 17 00:00:00 2001 From: huiyuxie Date: Thu, 19 Sep 2024 22:43:43 -0400 Subject: [PATCH 1/2] Rename package --- Project.toml | 2 +- README.md | 18 +-- examples/advection_basic_1d.jl | 4 +- examples/advection_basic_2d.jl | 4 +- examples/advection_basic_3d.jl | 4 +- examples/advection_mortar_2d.jl | 4 +- examples/advection_mortar_3d.jl | 4 +- examples/euler_ec_1d.jl | 4 +- examples/euler_ec_2d.jl | 4 +- examples/euler_ec_3d.jl | 4 +- examples/euler_shockcapturing_1d.jl | 4 +- examples/euler_shockcapturing_2d.jl | 4 +- examples/euler_shockcapturing_3d.jl | 4 +- examples/euler_source_terms_1d.jl | 4 +- examples/euler_source_terms_2d.jl | 4 +- examples/euler_source_terms_3d.jl | 4 +- examples/eulermulti_ec_1d.jl | 4 +- examples/eulermulti_ec_2d.jl | 4 +- examples/hypdiff_nonperiodic_1d.jl | 4 +- examples/hypdiff_nonperiodic_2d.jl | 4 +- examples/hypdiff_nonperiodic_3d.jl | 4 +- examples/shallowwater_dirichlet_1d.jl | 4 +- examples/shallowwater_dirichlet_2d.jl | 4 +- examples/shallowwater_ec_1d.jl | 4 +- examples/shallowwater_ec_2d.jl | 4 +- examples/shallowwater_source_terms_1d.jl | 4 +- examples/shallowwater_source_terms_2d.jl | 4 +- src/{TrixiGPU.jl => TrixiCUDA.jl} | 4 +- test/dgsem_tree_test_suite.jl | 122 +++++++++--------- test/runtests.jl | 4 +- test/test_adevction_mortar.jl | 92 +++++++------- test/test_advection_basic.jl | 127 ++++++++++--------- test/test_euler_dirichlet.jl | 127 ++++++++++--------- test/test_euler_ec.jl | 127 ++++++++++--------- test/test_euler_shockcapturing.jl | 127 ++++++++++--------- test/test_euler_source_terms.jl | 127 ++++++++++--------- test/test_eulermulti_ec.jl | 82 ++++++------ test/test_hypdiff_nonperiodic.jl | 127 ++++++++++--------- test/test_mhd_alfven_wave_mortar.jl | 92 +++++++------- test/test_mhd_ec.jl | 127 ++++++++++--------- test/test_mhd_shockcapturing.jl | 92 +++++++------- test/test_script.jl | 30 ++--- test/test_shallowwater_dirichlet.jl | 82 ++++++------ test/test_shallowwater_ec.jl | 82 ++++++------ test/test_shallowwater_shockcapturing.jl | 14 +- test/test_shallowwater_source_terms.jl | 82 ++++++------ test/{test_trixigpu.jl => test_trixicuda.jl} | 2 +- 47 files changed, 912 insertions(+), 877 deletions(-) rename src/{TrixiGPU.jl => TrixiCUDA.jl} (93%) rename test/{test_trixigpu.jl => test_trixicuda.jl} (99%) diff --git a/Project.toml b/Project.toml index 7ca56e36..781009d6 100644 --- a/Project.toml +++ b/Project.toml @@ -1,4 +1,4 @@ -name = "TrixiGPU" +name = "TrixiCUDA" uuid = "5056661c-942a-472c-b3bc-01507f717a60" authors = ["Huiyu Xie"] version = "1.0.0-DEV" diff --git a/README.md b/README.md index de8df306..ebeb69f2 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,9 @@ -# TrixiGPU.jl +# TrixiCUDA.jl -[![Build Status](https://github.com/huiyuxie/TrixiGPU.jl/actions/workflows/CI.yml/badge.svg?branch=main)](https://github.com/huiyuxie/TrixiGPU.jl/actions/workflows/CI.yml?query=branch%3Amain) +[![Build Status](https://github.com/huiyuxie/TrixiCUDA.jl/actions/workflows/CI.yml/badge.svg?branch=main)](https://github.com/huiyuxie/TrixiCUDA.jl/actions/workflows/CI.yml?query=branch%3Amain) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT) -**TrixiGPU.jl** is a component package of the [**Trixi.jl**](https://github.com/trixi-framework/Trixi.jl) ecosystem and provides GPU acceleration support for solving hyperbolic partial differential equations (PDEs). This package was initialized through the [**Google Summer of Code**](https://summerofcode.withgoogle.com/archive/2023/projects/upstR7K2) program in 2023 and is under active development and testing. +**TrixiCUDA.jl** is a component package of the [**Trixi.jl**](https://github.com/trixi-framework/Trixi.jl) ecosystem and provides GPU acceleration support for solving hyperbolic partial differential equations (PDEs). This package was initialized through the [**Google Summer of Code**](https://summerofcode.withgoogle.com/archive/2023/projects/upstR7K2) program in 2023 and is under active development and testing. The acceleration focus of this package is currently on the semidiscretization part (with plans to extend to other parts) of the PDE solvers, and [**CUDA.jl**](https://github.com/JuliaGPU/CUDA.jl) is our primary support (will expand to more types of GPUs using [**AMDGPU.jl**](https://github.com/JuliaGPU/AMDGPU.jl), [**OneAPI.jl**](https://github.com/JuliaGPU/oneAPI.jl), and [**Metal.jl**](https://github.com/JuliaGPU/Metal.jl) in the future). @@ -15,15 +15,15 @@ The package is now in pre-release status and will be registered once the initial ## Users Users who are interested now can install the package by running the following command in the Julia REPL: ```julia -julia> using Pkg; Pkg.add(url="https://github.com/czha/TrixiGPU.jl.git") +julia> using Pkg; Pkg.add(url="https://github.com/czha/TrixiCUDA.jl.git") ``` Then the package can be used with the following simple command: ```julia -julia> using TrixiGPU +julia> using TrixiCUDA ``` This package serves as a support package, so it is recommended to these packages together: ```julia -julia> using Trixi, TrixiGPU, OrdinaryDiffEq +julia> using Trixi, TrixiCUDA, OrdinaryDiffEq ``` ## Developers @@ -48,11 +48,11 @@ Our current focus is on the semidiscretization of PDEs. The table below shows th | `DGMultiMesh` | 1D, 2D, 3D | `DGMulti` | 🟡 Planned | # Example of PDE Semidiscretization on GPU -Let's take a look at a simple example to see how to use **TrixiGPU.jl** to run the simulation on the GPU (now only CUDA-compatible). +Let's take a look at a simple example to see how to use **TrixiCUDA.jl** to run the simulation on the GPU (now only CUDA-compatible). ```julia # Take 1D linear advection equation as an example -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq ############################################################################### @@ -76,7 +76,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition_convergen ############################################################################### # ODE solvers, callbacks etc. -ode = semidiscretize_gpu(semi, (0.0, 1.0)) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, (0.0, 1.0)) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/advection_basic_1d.jl b/examples/advection_basic_1d.jl index 32adf96b..2a31644f 100644 --- a/examples/advection_basic_1d.jl +++ b/examples/advection_basic_1d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -28,7 +28,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition_convergen # ODE solvers, callbacks etc. # Create ODE problem with time span from 0.0 to 1.0 -ode = semidiscretize_gpu(semi, (0.0, 1.0)) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, (0.0, 1.0)) # from TrixiCUDA.jl # At the beginning of the main loop, the SummaryCallback prints a summary of the simulation setup # and resets the timers diff --git a/examples/advection_basic_2d.jl b/examples/advection_basic_2d.jl index 0fa99dd9..5e7b0986 100644 --- a/examples/advection_basic_2d.jl +++ b/examples/advection_basic_2d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -28,7 +28,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition_convergen # ODE solvers, callbacks etc. # Create ODE problem with time span from 0.0 to 1.0 -ode = semidiscretize_gpu(semi, (0.0, 1.0)) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, (0.0, 1.0)) # from TrixiCUDA.jl # At the beginning of the main loop, the SummaryCallback prints a summary of the simulation setup # and resets the timers diff --git a/examples/advection_basic_3d.jl b/examples/advection_basic_3d.jl index e5c30d05..e716835e 100644 --- a/examples/advection_basic_3d.jl +++ b/examples/advection_basic_3d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -28,7 +28,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition_convergen # ODE solvers, callbacks etc. # Create ODE problem with time span from 0.0 to 1.0 -ode = semidiscretize_gpu(semi, (0.0, 1.0)) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, (0.0, 1.0)) # from TrixiCUDA.jl # At the beginning of the main loop, the SummaryCallback prints a summary of the simulation setup # and resets the timers diff --git a/examples/advection_mortar_2d.jl b/examples/advection_mortar_2d.jl index 68a2500f..4c17a515 100644 --- a/examples/advection_mortar_2d.jl +++ b/examples/advection_mortar_2d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -27,7 +27,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver) # ODE solvers, callbacks etc. tspan = (0.0, 1.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/advection_mortar_3d.jl b/examples/advection_mortar_3d.jl index 70e28efa..2c7c71f9 100644 --- a/examples/advection_mortar_3d.jl +++ b/examples/advection_mortar_3d.jl @@ -1,5 +1,5 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -30,7 +30,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver) # ODE solvers, callbacks etc. tspan = (0.0, 5.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/euler_ec_1d.jl b/examples/euler_ec_1d.jl index 9abf63f1..5a323742 100644 --- a/examples/euler_ec_1d.jl +++ b/examples/euler_ec_1d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -25,7 +25,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver) # ODE solvers, callbacks etc. tspan = (0.0, 0.4) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/euler_ec_2d.jl b/examples/euler_ec_2d.jl index 11a0f6ef..1dab39e5 100644 --- a/examples/euler_ec_2d.jl +++ b/examples/euler_ec_2d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -27,7 +27,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver, # ODE solvers, callbacks etc. tspan = (0.0, 0.4) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/euler_ec_3d.jl b/examples/euler_ec_3d.jl index 179e07e5..70c118e8 100644 --- a/examples/euler_ec_3d.jl +++ b/examples/euler_ec_3d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -26,7 +26,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver) # ODE solvers, callbacks etc. tspan = (0.0, 0.4) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/euler_shockcapturing_1d.jl b/examples/euler_shockcapturing_1d.jl index c2981910..03db7619 100644 --- a/examples/euler_shockcapturing_1d.jl +++ b/examples/euler_shockcapturing_1d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -35,7 +35,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver) # ODE solvers, callbacks etc. tspan = (0.0, 1.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/euler_shockcapturing_2d.jl b/examples/euler_shockcapturing_2d.jl index ea8c9cc8..2eae8ed1 100644 --- a/examples/euler_shockcapturing_2d.jl +++ b/examples/euler_shockcapturing_2d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -35,7 +35,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver) # ODE solvers, callbacks etc. tspan = (0.0, 1.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/euler_shockcapturing_3d.jl b/examples/euler_shockcapturing_3d.jl index 52f57d9c..457105ee 100644 --- a/examples/euler_shockcapturing_3d.jl +++ b/examples/euler_shockcapturing_3d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -37,7 +37,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver) # ODE solvers, callbacks etc. tspan = (0.0, 0.4) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/euler_source_terms_1d.jl b/examples/euler_source_terms_1d.jl index 1f8b1938..8389c7ab 100644 --- a/examples/euler_source_terms_1d.jl +++ b/examples/euler_source_terms_1d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -27,7 +27,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver, # ODE solvers, callbacks etc. tspan = (0.0, 2.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/euler_source_terms_2d.jl b/examples/euler_source_terms_2d.jl index 17ade96f..e28153c4 100644 --- a/examples/euler_source_terms_2d.jl +++ b/examples/euler_source_terms_2d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -24,7 +24,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver, # ODE solvers, callbacks etc. tspan = (0.0, 2.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/euler_source_terms_3d.jl b/examples/euler_source_terms_3d.jl index 1dfa3bce..b6a403c7 100644 --- a/examples/euler_source_terms_3d.jl +++ b/examples/euler_source_terms_3d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -26,7 +26,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver, # ODE solvers, callbacks etc. tspan = (0.0, 5.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/eulermulti_ec_1d.jl b/examples/eulermulti_ec_1d.jl index 98ef4f9e..03fd8614 100644 --- a/examples/eulermulti_ec_1d.jl +++ b/examples/eulermulti_ec_1d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -26,7 +26,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver) # ODE solvers, callbacks etc. tspan = (0.0, 0.4) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/eulermulti_ec_2d.jl b/examples/eulermulti_ec_2d.jl index ad28a1c8..0db5c01d 100644 --- a/examples/eulermulti_ec_2d.jl +++ b/examples/eulermulti_ec_2d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -26,7 +26,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver) # ODE solvers, callbacks etc. tspan = (0.0, 0.4) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/hypdiff_nonperiodic_1d.jl b/examples/hypdiff_nonperiodic_1d.jl index 6488efda..b4b1b58b 100644 --- a/examples/hypdiff_nonperiodic_1d.jl +++ b/examples/hypdiff_nonperiodic_1d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -29,7 +29,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver, # ODE solvers, callbacks etc. tspan = (0.0, 5.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/hypdiff_nonperiodic_2d.jl b/examples/hypdiff_nonperiodic_2d.jl index 8b76594f..622e5e21 100644 --- a/examples/hypdiff_nonperiodic_2d.jl +++ b/examples/hypdiff_nonperiodic_2d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -32,7 +32,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver, # ODE solvers, callbacks etc. tspan = (0.0, 5.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/hypdiff_nonperiodic_3d.jl b/examples/hypdiff_nonperiodic_3d.jl index 99cd03c7..03afb06c 100644 --- a/examples/hypdiff_nonperiodic_3d.jl +++ b/examples/hypdiff_nonperiodic_3d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -33,7 +33,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver, # ODE solvers, callbacks etc. tspan = (0.0, 5.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/shallowwater_dirichlet_1d.jl b/examples/shallowwater_dirichlet_1d.jl index 97159c42..609287a7 100644 --- a/examples/shallowwater_dirichlet_1d.jl +++ b/examples/shallowwater_dirichlet_1d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -39,7 +39,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver, # ODE solvers, callbacks etc. tspan = (0.0, 1.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/shallowwater_dirichlet_2d.jl b/examples/shallowwater_dirichlet_2d.jl index f3e02e2b..baedfdf8 100644 --- a/examples/shallowwater_dirichlet_2d.jl +++ b/examples/shallowwater_dirichlet_2d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -39,7 +39,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver, # ODE solvers, callbacks etc. tspan = (0.0, 1.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/shallowwater_ec_1d.jl b/examples/shallowwater_ec_1d.jl index c3cbd27d..c06d6fb0 100644 --- a/examples/shallowwater_ec_1d.jl +++ b/examples/shallowwater_ec_1d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -65,7 +65,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver) # ODE solver tspan = (0.0, 2.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl ############################################################################### # Callbacks diff --git a/examples/shallowwater_ec_2d.jl b/examples/shallowwater_ec_2d.jl index 9853a511..fa60e2af 100644 --- a/examples/shallowwater_ec_2d.jl +++ b/examples/shallowwater_ec_2d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -37,7 +37,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver) # ODE solver tspan = (0.0, 2.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl ############################################################################### # Workaround to set a discontinuous bottom topography and initial condition for debugging and testing. diff --git a/examples/shallowwater_source_terms_1d.jl b/examples/shallowwater_source_terms_1d.jl index 9cc384ec..fc1ba400 100644 --- a/examples/shallowwater_source_terms_1d.jl +++ b/examples/shallowwater_source_terms_1d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -36,7 +36,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver, # ODE solvers, callbacks etc. tspan = (0.0, 1.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/examples/shallowwater_source_terms_2d.jl b/examples/shallowwater_source_terms_2d.jl index a2145c7e..272c5cdb 100644 --- a/examples/shallowwater_source_terms_2d.jl +++ b/examples/shallowwater_source_terms_2d.jl @@ -1,4 +1,4 @@ -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using OrdinaryDiffEq # The example is taken from the Trixi.jl @@ -36,7 +36,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver, # ODE solvers, callbacks etc. tspan = (0.0, 1.0) -ode = semidiscretize_gpu(semi, tspan) # from TrixiGPU.jl +ode = semidiscretize_gpu(semi, tspan) # from TrixiCUDA.jl summary_callback = SummaryCallback() diff --git a/src/TrixiGPU.jl b/src/TrixiCUDA.jl similarity index 93% rename from src/TrixiGPU.jl rename to src/TrixiCUDA.jl index 5a30c41c..7d551e7f 100644 --- a/src/TrixiGPU.jl +++ b/src/TrixiCUDA.jl @@ -1,6 +1,6 @@ -module TrixiGPU +module TrixiCUDA -# Include other packages that are used in TrixiGPU.jl +# Include other packages that are used in TrixiCUDA.jl # using Reexport: @reexport using CUDA: @cuda, CuArray, HostKernel, diff --git a/test/dgsem_tree_test_suite.jl b/test/dgsem_tree_test_suite.jl index 98dcc70f..652a81f4 100644 --- a/test/dgsem_tree_test_suite.jl +++ b/test/dgsem_tree_test_suite.jl @@ -22,63 +22,63 @@ function run_dgsem_tree_tests_1D(semi, tspan) du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end # Test suite for 2D problems @@ -103,80 +103,80 @@ function run_dgsem_tree_tests_2D(semi, tspan) du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end # Test suite for 3D problems @@ -201,49 +201,49 @@ function run_dgsem_tree_tests_3D(semi, tspan) du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper_left ≈ cache.mortars.u_upper_left @@ -252,29 +252,29 @@ function run_dgsem_tree_tests_3D(semi, tspan) @test_approx cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end diff --git a/test/runtests.jl b/test/runtests.jl index d6b57b41..a1c6c226 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,4 +1,4 @@ -using TrixiGPU +using TrixiCUDA using Test # Note that it is complicated to get tight error bounds for GPU kernels, here we use `isapprox` @@ -6,4 +6,4 @@ using Test # CPU kernels, which corresponds to requiring equality of about half of the significant digits # (see https://docs.julialang.org/en/v1/base/math/#Base.isapprox). -@testset "TrixiGPU.jl" begin end +@testset "TrixiCUDA.jl" begin end diff --git a/test/test_adevction_mortar.jl b/test/test_adevction_mortar.jl index d3a2c6eb..7d4ac473 100644 --- a/test/test_adevction_mortar.jl +++ b/test/test_adevction_mortar.jl @@ -9,7 +9,7 @@ module TestLinearAdvectionMortar # - `cache_mortars::True` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Linear Advection" begin @@ -53,80 +53,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache.mortars.u_upper ≈ cache_gpu.mortars.u_upper @test_approx cache.mortars.u_lower ≈ cache_gpu.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Linear AdVection 3D" begin @@ -171,49 +172,50 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper_left ≈ cache.mortars.u_upper_left @@ -222,31 +224,31 @@ include("test_trixigpu.jl") @test_approx cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_advection_basic.jl b/test/test_advection_basic.jl index 66ecbd94..8cce86d2 100644 --- a/test/test_advection_basic.jl +++ b/test/test_advection_basic.jl @@ -9,7 +9,7 @@ module TestLinearAdvectionBasic # - `periodicity = true` 1D, 2D, 3D ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Linear Advection" begin @@ -50,63 +50,64 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Linear Advection 2D" begin @@ -146,80 +147,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Linear AdVection 3D" begin @@ -259,49 +261,50 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper_left ≈ cache.mortars.u_upper_left @@ -310,31 +313,31 @@ include("test_trixigpu.jl") @test_approx cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_euler_dirichlet.jl b/test/test_euler_dirichlet.jl index 23c5f76a..3ccbe41e 100644 --- a/test/test_euler_dirichlet.jl +++ b/test/test_euler_dirichlet.jl @@ -10,7 +10,7 @@ module TestCompressibleEulerBoundary # - `source_terms` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Compressible Euler" begin @@ -56,63 +56,64 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Compressible Euler 2D" begin @@ -161,80 +162,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Compressible Euler 3D" begin @@ -285,49 +287,50 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper_left ≈ cache.mortars.u_upper_left @@ -336,31 +339,31 @@ include("test_trixigpu.jl") @test_approx cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_euler_ec.jl b/test/test_euler_ec.jl index ec77fef2..c73ebff9 100644 --- a/test/test_euler_ec.jl +++ b/test/test_euler_ec.jl @@ -8,7 +8,7 @@ module TestCompressibleEulerFluxDifferencing # - `volume_integral::VolumeIntegralFluxDifferencing` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Compressible Euler" begin @@ -50,63 +50,64 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Compressible Euler 2D" begin @@ -148,80 +149,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Compressible Euler 3D" begin @@ -262,49 +264,50 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper_left ≈ cache.mortars.u_upper_left @@ -313,31 +316,31 @@ include("test_trixigpu.jl") @test_approx cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_euler_shockcapturing.jl b/test/test_euler_shockcapturing.jl index b81ca1d1..a6b771e5 100644 --- a/test/test_euler_shockcapturing.jl +++ b/test/test_euler_shockcapturing.jl @@ -9,7 +9,7 @@ module TestCompressibleEulerShock # - `volume_integral::VolumeIntegralShockCapturingHG` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Compressible Euler" begin @@ -61,63 +61,64 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Compressible Euler 2D" begin @@ -168,80 +169,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Compressible Euler 3D" begin @@ -294,49 +296,50 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test cache_gpu.mortars.u_upper_left ≈ cache.mortars.u_upper_left @@ -345,31 +348,31 @@ include("test_trixigpu.jl") @test cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_euler_source_terms.jl b/test/test_euler_source_terms.jl index dab849a1..4dad3053 100644 --- a/test/test_euler_source_terms.jl +++ b/test/test_euler_source_terms.jl @@ -8,7 +8,7 @@ module TestCompressibleEulerSourceTerms # - `source_terms` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Compressible Euler" begin @@ -50,63 +50,64 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Compressible Euler 2D" begin @@ -146,80 +147,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Compressible Euler 3D" begin @@ -261,49 +263,50 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper_left ≈ cache.mortars.u_upper_left @@ -312,31 +315,31 @@ include("test_trixigpu.jl") @test_approx cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_eulermulti_ec.jl b/test/test_eulermulti_ec.jl index 7433605a..7ccd257c 100644 --- a/test/test_eulermulti_ec.jl +++ b/test/test_eulermulti_ec.jl @@ -8,7 +8,7 @@ module TestCompressibleEulerMultiFluxDifferencing # - `volume_integral::VolumeIntegralFluxDifferencing` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Compressible Euler Multicomponent" begin @@ -52,63 +52,64 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Compressible Euler Multicomponent 2D" begin @@ -151,80 +152,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_hypdiff_nonperiodic.jl b/test/test_hypdiff_nonperiodic.jl index afb1722d..ddc0dff7 100644 --- a/test/test_hypdiff_nonperiodic.jl +++ b/test/test_hypdiff_nonperiodic.jl @@ -11,7 +11,7 @@ module TestHyperbolicDiffusionBoundary # - `periodicity = (false, true, true)` 3D ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Hyperbolic Diffusion" begin @@ -57,63 +57,64 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Compressible Euler 2D" begin @@ -161,80 +162,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Compressible Euler 3D" begin @@ -283,49 +285,50 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper_left ≈ cache.mortars.u_upper_left @@ -334,31 +337,31 @@ include("test_trixigpu.jl") @test_approx cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_mhd_alfven_wave_mortar.jl b/test/test_mhd_alfven_wave_mortar.jl index 372098c4..e745810d 100644 --- a/test/test_mhd_alfven_wave_mortar.jl +++ b/test/test_mhd_alfven_wave_mortar.jl @@ -11,7 +11,7 @@ module TestMHDMortar # - `cache_mortars::True` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Ideal GLM MHD" begin @@ -59,80 +59,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Ideal GLM MHD 3D" begin @@ -179,49 +180,50 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper_left ≈ cache.mortars.u_upper_left @@ -230,31 +232,31 @@ include("test_trixigpu.jl") @test_approx cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_mhd_ec.jl b/test/test_mhd_ec.jl index 10903b68..e6d1a70d 100644 --- a/test/test_mhd_ec.jl +++ b/test/test_mhd_ec.jl @@ -8,7 +8,7 @@ module TestMHDFluxDifferencing # - `volume_integral::VolumeIntegralFluxDifferencing` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Ideal GLM MHD" begin @@ -52,63 +52,64 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Ideal GLM MHD 2D" begin @@ -151,80 +152,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Ideal GLM MHD 3D" begin @@ -267,49 +269,50 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper_left ≈ cache.mortars.u_upper_left @@ -318,31 +321,31 @@ include("test_trixigpu.jl") @test_approx cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_mhd_shockcapturing.jl b/test/test_mhd_shockcapturing.jl index 2b655216..e5a95d66 100644 --- a/test/test_mhd_shockcapturing.jl +++ b/test/test_mhd_shockcapturing.jl @@ -11,7 +11,7 @@ module TestMHDShock # - `volume_integral::VolumeIntegralShockCapturingHG` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Ideal GLM MHD" begin @@ -66,80 +66,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Ideal GLM MHD 3D" begin @@ -193,49 +194,50 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper_left ≈ cache.mortars.u_upper_left @@ -244,31 +246,31 @@ include("test_trixigpu.jl") @test_approx cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_script.jl b/test/test_script.jl index 53c60308..4bf5eacb 100644 --- a/test/test_script.jl +++ b/test/test_script.jl @@ -1,4 +1,4 @@ -include("test_trixigpu.jl") +include("test_trixicuda.jl") equations = IdealGlmMhdEquations1D(1.4) @@ -50,26 +50,26 @@ u = Trixi.wrap_array(u_ode, mesh, equations, solver, cache) du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device -du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) +du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` -TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) +TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # # Test `cuda_prolong2interfaces!` -# TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) +# TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) # Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) # @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # # Test `cuda_interface_flux!` -# TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), +# TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), # equations_gpu, solver_gpu, cache_gpu) # Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, # Trixi.have_nonconservative_terms(equations), equations, @@ -77,13 +77,13 @@ Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equati # @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # # Test `cuda_prolong2boundaries!` -# TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, +# TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, # cache_gpu) # Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) # @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # # Test `cuda_boundary_flux!` -# TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, +# TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, # Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, # solver_gpu, cache_gpu) # Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, @@ -91,7 +91,7 @@ Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equati # @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # # Test `cuda_prolong2mortars!` -# TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), +# TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), # solver_gpu, cache_gpu) # Trixi.prolong2mortars!(cache, u, mesh, equations, # solver.mortar, solver.surface_integral, solver) @@ -101,7 +101,7 @@ Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equati # @test_approx cache_gpu.mortars.u_lower_right ≈ cache.mortars.u_lower_right # # Test `cuda_mortar_flux!` -# TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), +# TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), # Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, # solver_gpu, cache_gpu) # Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, @@ -110,16 +110,16 @@ Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equati # @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # # Test `cuda_surface_integral!` -# TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) +# TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) # Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) # @test_approx du_gpu ≈ du # # Test `cuda_jacobian!` -# TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) +# TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) # Trixi.apply_jacobian!(du, mesh, equations, solver, cache) # @test_approx du_gpu ≈ du # # Test `cuda_sources!` -# TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) +# TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) # Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) # @test_approx du_gpu ≈ du diff --git a/test/test_shallowwater_dirichlet.jl b/test/test_shallowwater_dirichlet.jl index aeef55ea..51edf5aa 100644 --- a/test/test_shallowwater_dirichlet.jl +++ b/test/test_shallowwater_dirichlet.jl @@ -9,7 +9,7 @@ module TestShallowWaterBoundary # - `periodicity = false` 1D, 2D, 3D - `BoundaryConditionDirichlet` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Shallow Water" begin @@ -58,63 +58,64 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Shallow Water 2D" begin @@ -162,80 +163,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_shallowwater_ec.jl b/test/test_shallowwater_ec.jl index a23674dd..d52405b7 100644 --- a/test/test_shallowwater_ec.jl +++ b/test/test_shallowwater_ec.jl @@ -8,7 +8,7 @@ module TestShallowWaterFluxDifferencing # - `volume_integral::VolumeIntegralFluxDifferencing` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Shallow Water" begin @@ -72,63 +72,64 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Shallow Water 2D" begin @@ -216,80 +217,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_shallowwater_shockcapturing.jl b/test/test_shallowwater_shockcapturing.jl index b91760ea..e140b2cf 100644 --- a/test/test_shallowwater_shockcapturing.jl +++ b/test/test_shallowwater_shockcapturing.jl @@ -11,7 +11,7 @@ module TestShallowWaterShock # - `volume_integral::VolumeIntegralShockCapturingHG` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Shallow Water" begin @@ -98,15 +98,15 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du @@ -114,7 +114,7 @@ include("test_trixigpu.jl") # Wait for fix of boundary flux dispatches # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Shallow Water 2D" begin end diff --git a/test/test_shallowwater_source_terms.jl b/test/test_shallowwater_source_terms.jl index 76cf02e8..ca2b559e 100644 --- a/test/test_shallowwater_source_terms.jl +++ b/test/test_shallowwater_source_terms.jl @@ -9,7 +9,7 @@ module TestShallowWaterSourceTerms # - `source_terms` ####################################################################### -include("test_trixigpu.jl") +include("test_trixicuda.jl") # Test precision of the semidiscretization process @testset "Test Shallow Water" begin @@ -55,63 +55,64 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end @testset "Shallow Water 2D" begin @@ -156,80 +157,81 @@ include("test_trixigpu.jl") du = Trixi.wrap_array(du_ode, mesh, equations, solver, cache) # Copy data to device - du_gpu, u_gpu = TrixiGPU.copy_to_device!(du, u) + du_gpu, u_gpu = TrixiCUDA.copy_to_device!(du, u) # Reset data on host Trixi.reset_du!(du, solver, cache) # Test `cuda_volume_integral!` - TrixiGPU.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, - Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu.volume_integral, solver_gpu, - cache_gpu) + TrixiCUDA.cuda_volume_integral!(du_gpu, u_gpu, mesh_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu.volume_integral, solver_gpu, + cache_gpu) Trixi.calc_volume_integral!(du, u, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.volume_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_prolong2interfaces!` - TrixiGPU.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2interfaces!(u_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.prolong2interfaces!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.interfaces.u ≈ cache.interfaces.u # Test `cuda_interface_flux!` - TrixiGPU.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), - equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_interface_flux!(mesh_gpu, Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, solver_gpu, cache_gpu) Trixi.calc_interface_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2boundaries!` - TrixiGPU.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, - cache_gpu) + TrixiCUDA.cuda_prolong2boundaries!(u_gpu, mesh_gpu, boundary_conditions_gpu, equations_gpu, + cache_gpu) Trixi.prolong2boundaries!(cache, u, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.boundaries.u ≈ cache.boundaries.u # Test `cuda_boundary_flux!` - TrixiGPU.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_boundary_flux!(t_gpu, mesh_gpu, boundary_conditions_gpu, + Trixi.have_nonconservative_terms(equations_gpu), + equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_boundary_flux!(cache, t, boundary_conditions, mesh, equations, solver.surface_integral, solver) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_prolong2mortars!` - TrixiGPU.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - solver_gpu, cache_gpu) + TrixiCUDA.cuda_prolong2mortars!(u_gpu, mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + solver_gpu, cache_gpu) Trixi.prolong2mortars!(cache, u, mesh, equations, solver.mortar, solver.surface_integral, solver) @test_approx cache_gpu.mortars.u_upper ≈ cache.mortars.u_upper @test_approx cache_gpu.mortars.u_lower ≈ cache.mortars.u_lower # Test `cuda_mortar_flux!` - TrixiGPU.cuda_mortar_flux!(mesh_gpu, TrixiGPU.check_cache_mortars(cache_gpu), - Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, - solver_gpu, cache_gpu) + TrixiCUDA.cuda_mortar_flux!(mesh_gpu, TrixiCUDA.check_cache_mortars(cache_gpu), + Trixi.have_nonconservative_terms(equations_gpu), equations_gpu, + solver_gpu, cache_gpu) Trixi.calc_mortar_flux!(cache.elements.surface_flux_values, mesh, Trixi.have_nonconservative_terms(equations), equations, solver.mortar, solver.surface_integral, solver, cache) @test_approx cache_gpu.elements.surface_flux_values ≈ cache.elements.surface_flux_values # Test `cuda_surface_integral!` - TrixiGPU.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) + TrixiCUDA.cuda_surface_integral!(du_gpu, mesh_gpu, equations_gpu, solver_gpu, cache_gpu) Trixi.calc_surface_integral!(du, u, mesh, equations, solver.surface_integral, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_jacobian!` - TrixiGPU.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_jacobian!(du_gpu, mesh_gpu, equations_gpu, cache_gpu) Trixi.apply_jacobian!(du, mesh, equations, solver, cache) @test_approx du_gpu ≈ du # Test `cuda_sources!` - TrixiGPU.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) + TrixiCUDA.cuda_sources!(du_gpu, u_gpu, t_gpu, source_terms_gpu, equations_gpu, cache_gpu) Trixi.calc_sources!(du, u, t, source_terms, equations, solver, cache) @test_approx du_gpu ≈ du # Copy data back to host - du_cpu, u_cpu = TrixiGPU.copy_to_host!(du_gpu, u_gpu) + du_cpu, u_cpu = TrixiCUDA.copy_to_host!(du_gpu, u_gpu) end end diff --git a/test/test_trixigpu.jl b/test/test_trixicuda.jl similarity index 99% rename from test/test_trixigpu.jl rename to test/test_trixicuda.jl index ef2a5a5a..e35fa651 100644 --- a/test/test_trixigpu.jl +++ b/test/test_trixicuda.jl @@ -1,7 +1,7 @@ # Create some macros to simplify the testing process. # Load the required packages, macros, and structs -using Trixi, TrixiGPU +using Trixi, TrixiCUDA using Test: @test, @testset # Macro to test the type Float64 or Float32 ? From 8d6f505a3f130cc449a1c52c6748f907db33ed49 Mon Sep 17 00:00:00 2001 From: huiyuxie Date: Thu, 19 Sep 2024 22:52:34 -0400 Subject: [PATCH 2/2] Complete --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index ebeb69f2..35b00b8f 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ The package is now in pre-release status and will be registered once the initial ## Users Users who are interested now can install the package by running the following command in the Julia REPL: ```julia -julia> using Pkg; Pkg.add(url="https://github.com/czha/TrixiCUDA.jl.git") +julia> using Pkg; Pkg.add(url="https://github.com/trixi-gpu/TrixiCUDA.jl.git") ``` Then the package can be used with the following simple command: ```julia @@ -100,7 +100,7 @@ summary_callback() ``` # Benchmarks -Coming... +Please check benchmark branch and this part will be updated soon. # Show Your Support We always welcome new contributors to join us in future development. Please feel free to reach out if you would like to get involved!