mirror of
https://github.com/JuliaFEM/JuliaFEM.jl.git
synced 2026-08-06 04:21:33 +00:00
Jukka Aho
239 lines
9.3 KiB
Julia
239 lines
9.3 KiB
Julia
# This file is a part of JuliaFEM.
|
||
# License is MIT: see https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/LICENSE.md
|
||
|
||
"""
|
||
Regression test: DOF-based assembler must stay zero-allocation
|
||
and bit-equivalent to the element-based assembler.
|
||
|
||
This test exists to lock in the December 2025 zero-allocation work
|
||
and to catch any regression as the assembler evolves.
|
||
|
||
Each problem size:
|
||
1. Build a structured Hex8 / Tet4 mesh
|
||
2. Create elements + DOFManager
|
||
3. Build both assemblers
|
||
4. Warm up
|
||
5. Assert: 0 bytes allocated by the DOF-based `assemble!`
|
||
6. Assert: matrix matches the element-based assembler to round-off
|
||
"""
|
||
|
||
using Test
|
||
using JuliaFEM
|
||
using JuliaFEM: DOFBasedCOOAssembler, DOFBasedCOOCache
|
||
using JuliaFEM: COOAssembler, create_cache
|
||
using JuliaFEM: create_elements!, @DOFSet, DOF, Displacement, Vertex
|
||
using JuliaFEM: local_dof_layout, DOFLayoutEntry
|
||
using LinearAlgebra
|
||
using SparseArrays
|
||
using Tensors
|
||
using InteractiveUtils # @code_typed, code_llvm
|
||
|
||
# ----------------------------------------------------------------------------
|
||
# Helpers (kept local to this test, no leak into package)
|
||
# ----------------------------------------------------------------------------
|
||
|
||
"""
|
||
Build a structured Hex8 box mesh with `nx × ny × nz` elements over [0,1]^3.
|
||
"""
|
||
function _build_hex8_box_mesh(nx::Int, ny::Int, nz::Int)
|
||
nodes = Vec{3,Float64}[]
|
||
nidx(i, j, k) = (i - 1) + (j - 1) * (nx + 1) + (k - 1) * (nx + 1) * (ny + 1) + 1
|
||
for k in 1:(nz + 1), j in 1:(ny + 1), i in 1:(nx + 1)
|
||
push!(nodes, Vec{3}((Float64(i - 1) / nx,
|
||
Float64(j - 1) / ny,
|
||
Float64(k - 1) / nz)))
|
||
end
|
||
conns = NTuple{8,UInt32}[]
|
||
for k in 1:nz, j in 1:ny, i in 1:nx
|
||
n1 = nidx(i, j, k)
|
||
n2 = nidx(i + 1, j, k)
|
||
n3 = nidx(i + 1, j + 1, k)
|
||
n4 = nidx(i, j + 1, k)
|
||
n5 = nidx(i, j, k + 1)
|
||
n6 = nidx(i + 1, j, k + 1)
|
||
n7 = nidx(i + 1, j + 1, k + 1)
|
||
n8 = nidx(i, j + 1, k + 1)
|
||
push!(conns, (UInt32(n1), UInt32(n2), UInt32(n3), UInt32(n4),
|
||
UInt32(n5), UInt32(n6), UInt32(n7), UInt32(n8)))
|
||
end
|
||
return Mesh{8,Hexahedron{8}}(nodes, conns)
|
||
end
|
||
|
||
"""
|
||
Build a single Tet4 mesh.
|
||
"""
|
||
function _build_single_tet4_mesh()
|
||
nodes = Vec{3,Float64}[
|
||
Vec{3}((0.0, 0.0, 0.0)),
|
||
Vec{3}((1.0, 0.0, 0.0)),
|
||
Vec{3}((0.5, 1.0, 0.0)),
|
||
Vec{3}((0.5, 0.5, 1.0)),
|
||
]
|
||
conns = [(UInt32(1), UInt32(2), UInt32(3), UInt32(4))]
|
||
return Mesh{Tetrahedron{4}}(nodes, conns)
|
||
end
|
||
|
||
"""
|
||
Setup elasticity assembly fixture for a given mesh + topology.
|
||
Returns (cache_dof, asm_dof, cache_elem, asm_elem, kernel, mesh).
|
||
"""
|
||
function _setup_assembly(mesh, ::Type{Topo}) where {Topo}
|
||
material = LinearElastic(E = 210e9, ν = 0.3)
|
||
kernel = ContinuumKernel(ContinuumFormulation{FullThreeD}(),
|
||
material, Displacement{3}())
|
||
|
||
S = @DOFSet{u::DOF{Displacement{3}, Vertex}}
|
||
elements, dof_mgr = create_elements!(mesh, Element{Topo, Lagrange{1}, S})
|
||
|
||
asm_dof = DOFBasedCOOAssembler()
|
||
cache_dof = DOFBasedCOOCache(elements, dof_mgr, mesh, kernel)
|
||
|
||
asm_elem = COOAssembler()
|
||
cache_elem = create_cache(asm_elem, mesh, kernel)
|
||
|
||
return cache_dof, asm_dof, cache_elem, asm_elem, kernel, mesh
|
||
end
|
||
|
||
# ----------------------------------------------------------------------------
|
||
# Tests
|
||
# ----------------------------------------------------------------------------
|
||
|
||
@testset "DOF-based assembler: zero allocation regression" begin
|
||
println("\n" * "=" ^ 70)
|
||
println("DOF-BASED ASSEMBLER ZERO-ALLOCATION REGRESSION")
|
||
println("=" ^ 70)
|
||
|
||
# ------------------------------------------------------------------------
|
||
# 1. Single Tet4
|
||
# ------------------------------------------------------------------------
|
||
@testset "Single Tet4" begin
|
||
mesh = _build_single_tet4_mesh()
|
||
cache_dof, asm_dof, cache_elem, asm_elem, kernel, m =
|
||
_setup_assembly(mesh, Tetrahedron{4})
|
||
|
||
# warmup
|
||
assemble!(cache_dof, asm_dof, kernel, m)
|
||
assemble!(cache_elem, asm_elem, kernel, m)
|
||
|
||
K_dof, _ = extract_system(cache_dof)
|
||
K_elem, _ = extract_system(cache_elem)
|
||
|
||
# Equivalence
|
||
rel = maximum(abs, Matrix(K_dof) - Matrix(K_elem)) /
|
||
max(maximum(abs, Matrix(K_elem)), 1.0)
|
||
@test rel < 1e-12
|
||
|
||
# Zero-alloc
|
||
GC.gc()
|
||
a = @allocated assemble!(cache_dof, asm_dof, kernel, m)
|
||
@test a == 0
|
||
println(" Single Tet4 ........................ allocs=$a, rel=$(round(rel; sigdigits=3))")
|
||
end
|
||
|
||
# ------------------------------------------------------------------------
|
||
# 2. Growing Hex8 cube meshes
|
||
# ------------------------------------------------------------------------
|
||
@testset "Hex8 cube $(nx)×$(ny)×$(nz)" for (nx, ny, nz) in
|
||
[(1, 1, 1), (2, 1, 1), (4, 2, 2), (6, 3, 3), (8, 4, 4)]
|
||
|
||
mesh = _build_hex8_box_mesh(nx, ny, nz)
|
||
cache_dof, asm_dof, cache_elem, asm_elem, kernel, m =
|
||
_setup_assembly(mesh, Hexahedron{8})
|
||
|
||
# warmup
|
||
assemble!(cache_dof, asm_dof, kernel, m)
|
||
assemble!(cache_elem, asm_elem, kernel, m)
|
||
|
||
K_dof, _ = extract_system(cache_dof)
|
||
K_elem, _ = extract_system(cache_elem)
|
||
|
||
rel = maximum(abs, Matrix(K_dof) - Matrix(K_elem)) /
|
||
max(maximum(abs, Matrix(K_elem)), 1.0)
|
||
@test rel < 1e-12
|
||
|
||
GC.gc()
|
||
a = @allocated assemble!(cache_dof, asm_dof, kernel, m)
|
||
@test a == 0
|
||
|
||
nelems = length(m.connectivity)
|
||
ndofs = 3 * length(m.nodes)
|
||
println(" Hex8 $(nx)×$(ny)×$(nz) $(lpad(nelems,5)) elem " *
|
||
"$(lpad(ndofs,5)) dof allocs=$a rel=$(round(rel; sigdigits=3))")
|
||
end
|
||
end
|
||
|
||
# ----------------------------------------------------------------------------
|
||
# Type stability check (no untyped ::Any in inferred output)
|
||
# ----------------------------------------------------------------------------
|
||
@testset "DOF-based assembler: type stability" begin
|
||
mesh = _build_hex8_box_mesh(2, 1, 1)
|
||
cache_dof, asm_dof, _, _, kernel, m = _setup_assembly(mesh, Hexahedron{8})
|
||
assemble!(cache_dof, asm_dof, kernel, m) # warmup
|
||
|
||
# Inferred return type must be concrete (Nothing).
|
||
rt = Base.promote_op(assemble!, typeof(cache_dof), typeof(asm_dof),
|
||
typeof(kernel), typeof(m))
|
||
@test rt === Nothing
|
||
|
||
# No method ambiguities or `Any` in the top-level signature
|
||
code = code_typed(assemble!, (typeof(cache_dof), typeof(asm_dof),
|
||
typeof(kernel), typeof(m)); optimize = true)
|
||
@test !isempty(code)
|
||
info = code[1]
|
||
@test isconcretetype(info.second)
|
||
println(" assemble! inferred return type: $(info.second)")
|
||
end
|
||
|
||
# ----------------------------------------------------------------------------
|
||
# Element-as-template: local_dof_layout(E) is compile-time constant and
|
||
# `assemble!` has zero GC allocation sites in the optimized LLVM IR.
|
||
# ----------------------------------------------------------------------------
|
||
@testset "DOF-based assembler: element template + LLVM allocs" begin
|
||
mesh = _build_hex8_box_mesh(2, 1, 1)
|
||
cache_dof, asm_dof, _, _, kernel, m = _setup_assembly(mesh, Hexahedron{8})
|
||
assemble!(cache_dof, asm_dof, kernel, m) # warmup
|
||
|
||
# ------------------------------------------------------------------
|
||
# 1. local_dof_layout returns the expected NTuple of DOFLayoutEntry
|
||
# for an Hex8 displacement element (24 DOFs, 8 vertices × 3 comp.)
|
||
# ------------------------------------------------------------------
|
||
ET = eltype(cache_dof.elements)
|
||
layout = local_dof_layout(ET)
|
||
@test layout isa NTuple{24, DOFLayoutEntry}
|
||
@test all(e -> e.field_idx == 1, layout)
|
||
@test [Int(e.entity_local) for e in layout] ==
|
||
repeat(1:8; inner = 3)
|
||
@test [Int(e.component) for e in layout] ==
|
||
repeat(1:3, 8)
|
||
|
||
# ------------------------------------------------------------------
|
||
# 2. local_dof_layout(ET) call is constant-folded by the compiler:
|
||
# @allocated must be 0 and the optimized typed-IR must report a
|
||
# `Core.Const` for the layout in `assemble!` — exercised already
|
||
# by the zero-allocation tests above. We assert separately here.
|
||
# ------------------------------------------------------------------
|
||
GC.gc()
|
||
a_layout = @allocated local_dof_layout(ET)
|
||
@test a_layout == 0
|
||
|
||
# ------------------------------------------------------------------
|
||
# 3. Optimized LLVM IR for `assemble!` must have ZERO GC allocation
|
||
# sites. This is the strongest guarantee: even if @allocated == 0
|
||
# today, this catches any future change that would re-introduce
|
||
# a heap-allocating call inside the inner loop.
|
||
# ------------------------------------------------------------------
|
||
iob = IOBuffer()
|
||
code_llvm(iob, assemble!,
|
||
Tuple{typeof(cache_dof), typeof(asm_dof),
|
||
typeof(kernel), typeof(m)}; optimize = true)
|
||
ir = String(take!(iob))
|
||
n_alloc =
|
||
length(collect(eachmatch(r"call.*julia\.gc_alloc", ir))) +
|
||
length(collect(eachmatch(r"call.*jl_gc_pool_alloc", ir))) +
|
||
length(collect(eachmatch(r"call.*jl_gc_big_alloc", ir))) +
|
||
length(collect(eachmatch(r"call.*jl_gc_alloc_typed", ir)))
|
||
@test n_alloc == 0
|
||
println(" assemble! optimized LLVM IR: $n_alloc gc-alloc sites " *
|
||
"($(length(ir)) IR chars)")
|
||
end
|