CoCalc -- test_performance_specializations

GitHub Repository: trixi-framework/Trixi.jl
Path: blob/main/test/test_performance_specializations_2d.jl
²⁰⁵⁵ views
1
module TestPerformanceSpecializations2D
2

3
using Test
4
using Trixi
5

6
include("test_trixi.jl")
7

8
EXAMPLES_DIR = examples_dir()
9

10
# Start with a clean environment: remove Trixi.jl output directory if it exists
11
outdir = "out"
12
isdir(outdir) && rm(outdir, recursive = true)
13

14
@testset "Performance specializations 2D" begin
15
#! format: noindent
16

17
@timed_testset "TreeMesh2D, flux_shima_etal_turbo" begin
18
    trixi_include(@__MODULE__,
19
                  joinpath(EXAMPLES_DIR, "tree_2d_dgsem", "elixir_euler_ec.jl"),
20
                  initial_refinement_level = 0, tspan = (0.0, 0.0), polydeg = 3,
21
                  volume_flux = flux_shima_etal_turbo,
22
                  surface_flux = flux_shima_etal_turbo)
23
    u_ode = copy(sol.u[end])
24
    du_ode = zero(u_ode)
25

26
    # Preserve original memory since it will be `unsafe_wrap`ped and might
27
    # thus otherwise be garbage collected
28
    GC.@preserve u_ode du_ode begin
29
        u = Trixi.wrap_array(u_ode, semi)
30
        du = Trixi.wrap_array(du_ode, semi)
31
        nonconservative_terms = Trixi.have_nonconservative_terms(semi.equations)
32

33
        # Call the optimized default version
34
        du .= 0
35
        Trixi.flux_differencing_kernel!(du, u, 1, semi.mesh,
36
                                        nonconservative_terms, semi.equations,
37
                                        semi.solver.volume_integral.volume_flux,
38
                                        semi.solver, semi.cache, true)
39
        du_specialized = du[:, :, :, 1]
40

41
        # Call the plain version - note the argument type `Function` of
42
        # `semi.solver.volume_integral.volume_flux`
43
        du .= 0
44
        invoke(Trixi.flux_differencing_kernel!,
45
               Tuple{typeof(du), typeof(u), Integer, typeof(semi.mesh),
46
                     typeof(nonconservative_terms), typeof(semi.equations),
47
                     Function, typeof(semi.solver), typeof(semi.cache), Bool},
48
               du, u, 1, semi.mesh,
49
               nonconservative_terms, semi.equations,
50
               semi.solver.volume_integral.volume_flux, semi.solver, semi.cache, true)
51
        du_baseline = du[:, :, :, 1]
52

53
        @test du_specialized ≈ du_baseline
54
    end
55
end
56

57
@timed_testset "TreeMesh2D, flux_ranocha_turbo" begin
58
    trixi_include(@__MODULE__,
59
                  joinpath(EXAMPLES_DIR, "tree_2d_dgsem", "elixir_euler_ec.jl"),
60
                  initial_refinement_level = 0, tspan = (0.0, 0.0), polydeg = 3,
61
                  volume_flux = flux_ranocha_turbo, surface_flux = flux_ranocha_turbo)
62
    u_ode = copy(sol.u[end])
63
    du_ode = zero(u_ode)
64

65
    # Preserve original memory since it will be `unsafe_wrap`ped and might
66
    # thus otherwise be garbage collected
67
    GC.@preserve u_ode du_ode begin
68
        u = Trixi.wrap_array(u_ode, semi)
69
        du = Trixi.wrap_array(du_ode, semi)
70
        nonconservative_terms = Trixi.have_nonconservative_terms(semi.equations)
71

72
        # Call the optimized default version
73
        du .= 0
74
        Trixi.flux_differencing_kernel!(du, u, 1, semi.mesh,
75
                                        nonconservative_terms, semi.equations,
76
                                        semi.solver.volume_integral.volume_flux,
77
                                        semi.solver, semi.cache, true)
78
        du_specialized = du[:, :, :, 1]
79

80
        # Call the plain version - note the argument type `Function` of
81
        # `semi.solver.volume_integral.volume_flux`
82
        du .= 0
83
        invoke(Trixi.flux_differencing_kernel!,
84
               Tuple{typeof(du), typeof(u), Integer, typeof(semi.mesh),
85
                     typeof(nonconservative_terms), typeof(semi.equations),
86
                     Function, typeof(semi.solver), typeof(semi.cache), Bool},
87
               du, u, 1, semi.mesh,
88
               nonconservative_terms, semi.equations,
89
               semi.solver.volume_integral.volume_flux, semi.solver, semi.cache, true)
90
        du_baseline = du[:, :, :, 1]
91

92
        @test du_specialized ≈ du_baseline
93
    end
94
end
95

96
@timed_testset "StructuredMesh2D, flux_shima_etal_turbo" begin
97
    trixi_include(@__MODULE__,
98
                  joinpath(EXAMPLES_DIR, "structured_2d_dgsem", "elixir_euler_ec.jl"),
99
                  cells_per_dimension = (1, 1), tspan = (0.0, 0.0), polydeg = 3,
100
                  volume_flux = flux_shima_etal_turbo,
101
                  surface_flux = flux_shima_etal_turbo)
102
    u_ode = copy(sol.u[end])
103
    du_ode = zero(u_ode)
104

105
    # Preserve original memory since it will be `unsafe_wrap`ped and might
106
    # thus otherwise be garbage collected
107
    GC.@preserve u_ode du_ode begin
108
        u = Trixi.wrap_array(u_ode, semi)
109
        du = Trixi.wrap_array(du_ode, semi)
110
        nonconservative_terms = Trixi.have_nonconservative_terms(semi.equations)
111

112
        # Call the optimized default version
113
        du .= 0
114
        Trixi.flux_differencing_kernel!(du, u, 1, semi.mesh,
115
                                        nonconservative_terms, semi.equations,
116
                                        semi.solver.volume_integral.volume_flux,
117
                                        semi.solver, semi.cache, true)
118
        du_specialized = du[:, :, :, 1]
119

120
        # Call the plain version - note the argument type `Function` of
121
        # `semi.solver.volume_integral.volume_flux`
122
        du .= 0
123
        invoke(Trixi.flux_differencing_kernel!,
124
               Tuple{typeof(du), typeof(u), Integer, typeof(semi.mesh),
125
                     typeof(nonconservative_terms), typeof(semi.equations),
126
                     Function, typeof(semi.solver), typeof(semi.cache), Bool},
127
               du, u, 1, semi.mesh,
128
               nonconservative_terms, semi.equations,
129
               semi.solver.volume_integral.volume_flux, semi.solver, semi.cache, true)
130
        du_baseline = du[:, :, :, 1]
131

132
        @test du_specialized ≈ du_baseline
133
    end
134
end
135

136
@timed_testset "StructuredMesh2D, flux_ranocha_turbo" begin
137
    trixi_include(@__MODULE__,
138
                  joinpath(EXAMPLES_DIR, "structured_2d_dgsem", "elixir_euler_ec.jl"),
139
                  cells_per_dimension = (1, 1), tspan = (0.0, 0.0), polydeg = 3,
140
                  volume_flux = flux_ranocha_turbo, surface_flux = flux_ranocha_turbo)
141
    u_ode = copy(sol.u[end])
142
    du_ode = zero(u_ode)
143

144
    # Preserve original memory since it will be `unsafe_wrap`ped and might
145
    # thus otherwise be garbage collected
146
    GC.@preserve u_ode du_ode begin
147
        u = Trixi.wrap_array(u_ode, semi)
148
        du = Trixi.wrap_array(du_ode, semi)
149
        nonconservative_terms = Trixi.have_nonconservative_terms(semi.equations)
150

151
        # Call the optimized default version
152
        du .= 0
153
        Trixi.flux_differencing_kernel!(du, u, 1, semi.mesh,
154
                                        nonconservative_terms, semi.equations,
155
                                        semi.solver.volume_integral.volume_flux,
156
                                        semi.solver, semi.cache, true)
157
        du_specialized = du[:, :, :, 1]
158

159
        # Call the plain version - note the argument type `Function` of
160
        # `semi.solver.volume_integral.volume_flux`
161
        du .= 0
162
        invoke(Trixi.flux_differencing_kernel!,
163
               Tuple{typeof(du), typeof(u), Integer, typeof(semi.mesh),
164
                     typeof(nonconservative_terms), typeof(semi.equations),
165
                     Function, typeof(semi.solver), typeof(semi.cache), Bool},
166
               du, u, 1, semi.mesh,
167
               nonconservative_terms, semi.equations,
168
               semi.solver.volume_integral.volume_flux, semi.solver, semi.cache, true)
169
        du_baseline = du[:, :, :, 1]
170

171
        @test du_specialized ≈ du_baseline
172
    end
173
end
174
end
175

176
# Clean up afterwards: delete Trixi.jl output directory
177
@test_nowarn rm(outdir, recursive = true)
178

179
end #module
180

181
Product

Resources

Company
