Update dependency HPCLinearAlgebra → HPCSparseArrays

Author: Sebastien Loisel

Project.toml

@@ -8,7 +8,7 @@ BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
 CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
 CUDSS_jll = "4889d778-9329-5762-9fec-0578a5d30366"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-HPCLinearAlgebra = "537374f1-5608-4525-82fb-641dce542540"
+HPCSparseArrays = "537374f1-5608-4525-82fb-641dce542540"
 MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195"
 MPIPreferences = "3da0fdf6-3ccc-4f1b-acd9-58baa6c99267"
 Metal = "dde4c033-4e86-420c-a63e-0dd931031962"
@@ -20,13 +20,13 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
 [sources]
-HPCLinearAlgebra = {path = "../HPCLinearAlgebra.jl"}
+HPCSparseArrays = {path = "../HPCSparseArrays.jl"}
 
 [compat]
 BenchmarkTools = "1.6"
 CUDA = "5.9.6"
 CUDSS_jll = "0.7.1"
-HPCLinearAlgebra = "0.1"
+HPCSparseArrays = "0.1"
 MPI = "0.20"
 MPIPreferences = "0.1.11"
 Metal = "1.9.1"

README.md

@@ -7,17 +7,17 @@
 
 **Author:** S. Loisel
 
-A Julia package that bridges MultiGridBarrier.jl and HPCLinearAlgebra.jl for distributed multigrid barrier computations using native MPI types.
+A Julia package that bridges MultiGridBarrier.jl and HPCSparseArrays.jl for distributed multigrid barrier computations using native MPI types.
 
 ## Overview
 
-MultiGridBarrierMPI.jl extends the MultiGridBarrier.jl package to work with HPCLinearAlgebra.jl's distributed matrix and vector types. This enables efficient parallel computation of multigrid barrier methods across multiple MPI ranks without requiring PETSc.
+MultiGridBarrierMPI.jl extends the MultiGridBarrier.jl package to work with HPCSparseArrays.jl's distributed matrix and vector types. This enables efficient parallel computation of multigrid barrier methods across multiple MPI ranks without requiring PETSc.
 
 ## Key Features
 
 - **1D, 2D, and 3D Support**: Full support for 1D, 2D triangular, and 3D hexahedral finite elements
 - **Seamless Integration**: Drop-in replacement for MultiGridBarrier's native types
-- **Pure Julia MPI**: Uses HPCLinearAlgebra.jl for distributed linear algebra (no external libraries required)
+- **Pure Julia MPI**: Uses HPCSparseArrays.jl for distributed linear algebra (no external libraries required)
 - **Type Conversion**: Easy conversion between native Julia arrays and MPI distributed types
 - **MPI-Aware**: All operations correctly handle MPI collective requirements
 - **MUMPS Solver**: Uses MUMPS direct solver for accurate Newton iterations
@@ -31,7 +31,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 
 # Solve with MPI distributed types (L=3 refinement levels)
 sol_mpi = fem2d_mpi_solve(Float64; L=3, p=1.0, verbose=false)
@@ -92,7 +92,7 @@ julia --project make.jl
 This package is part of a larger ecosystem:
 
 - **[MultiGridBarrier.jl](https://github.com/sloisel/MultiGridBarrier.jl)**: Core multigrid barrier method implementation
-- **[HPCLinearAlgebra.jl](https://github.com/sloisel/HPCLinearAlgebra.jl)**: Pure Julia distributed linear algebra with MPI
+- **[HPCSparseArrays.jl](https://github.com/sloisel/HPCSparseArrays.jl)**: Pure Julia distributed linear algebra with MPI
 - **MPI.jl**: Julia MPI bindings for distributed computing
 
 ## Requirements

docs/Project.toml

@@ -1,7 +1,7 @@
 [deps]
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 DocumenterTools = "35a29f4d-8980-5a13-9543-d66fff28ecb8"
-HPCLinearAlgebra = "537374f1-5608-4525-82fb-641dce542540"
+HPCSparseArrays = "537374f1-5608-4525-82fb-641dce542540"
 MultiGridBarrier = "9e2c1f1d-9131-4ad4-b32f-bd2a0b0ecd1e"
 MultiGridBarrierMPI = "abf18f27-d12f-4566-94ed-07bf0c385f70"
 

docs/src/api.md

@@ -104,12 +104,12 @@ The `AMGBSOL` type from MultiGridBarrier contains the complete solution:
 
 ## MPI and IO Utilities
 
-### HPCLinearAlgebra.io0()
+### HPCSparseArrays.io0()
 
 Returns an IO stream that only writes on rank 0:
 
 ```julia
-using HPCLinearAlgebra
+using HPCSparseArrays
 
 println(io0(), "This prints once from rank 0")
 ```
@@ -132,7 +132,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 using MultiGridBarrier
 using LinearAlgebra
 

docs/src/guide.md

@@ -30,7 +30,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 using MultiGridBarrier
 
 # Step 1: Solve with MPI distributed types
@@ -135,7 +135,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 using MultiGridBarrier
 
 # 1. Create native geometry with specific parameters
@@ -168,7 +168,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 using MultiGridBarrier
 using LinearAlgebra
 
@@ -193,10 +193,10 @@ end
 
 ### Printing from One Rank
 
-Use `io0()` from HPCLinearAlgebra to print from rank 0 only:
+Use `io0()` from HPCSparseArrays to print from rank 0 only:
 
 ```julia
-using HPCLinearAlgebra
+using HPCSparseArrays
 
 # This prints once (from rank 0)
 println(io0(), "Hello from rank 0!")
@@ -268,7 +268,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 
 # Solve a 1D problem with 4 multigrid levels (2^4 = 16 elements)
 sol = fem1d_mpi_solve(Float64; L=4, p=1.0, verbose=true)
@@ -297,7 +297,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 
 # Solve a 2D problem
 sol = fem2d_mpi_solve(Float64; L=2, p=1.0, verbose=true)
@@ -327,7 +327,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 
 # Solve a 3D problem with Q3 elements and 2 multigrid levels
 sol = fem3d_mpi_solve(Float64; L=2, k=3, p=1.0, verbose=true)
@@ -357,7 +357,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 using MultiGridBarrier
 
 # Create MPI geometry
@@ -393,7 +393,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 
 sol = fem2d_mpi_solve(Float64; L=3, p=1.0)
 sol_native = mpi_to_native(sol)

docs/src/index.md

@@ -10,17 +10,17 @@ v = string(pkgversion(MultiGridBarrierMPI))
 md"# MultiGridBarrierMPI.jl $v"
 ```
 
-**A Julia package that bridges MultiGridBarrier.jl and HPCLinearAlgebra.jl for distributed multigrid barrier computations.**
+**A Julia package that bridges MultiGridBarrier.jl and HPCSparseArrays.jl for distributed multigrid barrier computations.**
 
 ## Overview
 
-MultiGridBarrierMPI.jl extends the MultiGridBarrier.jl package to work with HPCLinearAlgebra.jl's distributed matrix and vector types. This enables efficient parallel computation of multigrid barrier methods across multiple MPI ranks using pure Julia distributed types (no PETSc required).
+MultiGridBarrierMPI.jl extends the MultiGridBarrier.jl package to work with HPCSparseArrays.jl's distributed matrix and vector types. This enables efficient parallel computation of multigrid barrier methods across multiple MPI ranks using pure Julia distributed types (no PETSc required).
 
 ## Key Features
 
 - **1D, 2D, and 3D Support**: Full support for 1D elements, 2D triangular, and 3D hexahedral finite elements
 - **Seamless Integration**: Drop-in replacement for MultiGridBarrier's native types
-- **Pure Julia MPI**: Uses HPCLinearAlgebra.jl for distributed linear algebra
+- **Pure Julia MPI**: Uses HPCSparseArrays.jl for distributed linear algebra
 - **Type Conversion**: Easy conversion between native Julia arrays and MPI distributed types
 - **MPI-Aware**: All operations correctly handle MPI collective requirements
 - **MUMPS Solver**: Uses MUMPS direct solver for accurate Newton iterations
@@ -34,7 +34,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 using MultiGridBarrier
 
 # Solve with MPI distributed types (L=3 refinement levels)
@@ -71,7 +71,7 @@ Depth = 2
 This package is part of a larger ecosystem:
 
 - **[MultiGridBarrier.jl](https://github.com/sloisel/MultiGridBarrier.jl)**: Core multigrid barrier method implementation (1D, 2D, and 3D)
-- **[HPCLinearAlgebra.jl](https://github.com/sloisel/HPCLinearAlgebra.jl)**: Pure Julia distributed linear algebra with MPI
+- **[HPCSparseArrays.jl](https://github.com/sloisel/HPCSparseArrays.jl)**: Pure Julia distributed linear algebra with MPI
 - **MPI.jl**: Julia MPI bindings for distributed computing
 
 ## Requirements

docs/src/installation.md

@@ -10,7 +10,7 @@ For HPC environments, you may want to configure MPI.jl to use your system's MPI
 
 ### MUMPS
 
-The package uses MUMPS for sparse direct solves through HPCLinearAlgebra.jl. MUMPS is typically available through your system's package manager or HPC module system.
+The package uses MUMPS for sparse direct solves through HPCSparseArrays.jl. MUMPS is typically available through your system's package manager or HPC module system.
 
 ## Package Installation
 
@@ -75,7 +75,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 
 # Your parallel code here
 sol = fem2d_mpi_solve(Float64; L=3, p=1.0)
@@ -89,7 +89,7 @@ mpiexec -n 4 julia --project my_program.jl
 ```
 
 !!! tip "Output from Rank 0 Only"
-    Use `io0()` from HPCLinearAlgebra for output to avoid duplicate messages:
+    Use `io0()` from HPCSparseArrays for output to avoid duplicate messages:
     ```julia
     println(io0(), "This prints once from rank 0")
     ```
@@ -106,7 +106,7 @@ using Pkg; Pkg.build("MPI")
 
 ### MUMPS Issues
 
-If MUMPS fails to load, ensure it's properly installed on your system and that HPCLinearAlgebra.jl can find it.
+If MUMPS fails to load, ensure it's properly installed on your system and that HPCSparseArrays.jl can find it.
 
 ### Test Failures
 

examples/basic_solve.jl

@@ -15,7 +15,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 using MultiGridBarrier
 using LinearAlgebra
 

examples/roundtrip_conversion.jl

@@ -16,7 +16,7 @@ using MPI
 MPI.Init()
 
 using MultiGridBarrierMPI
-using HPCLinearAlgebra
+using HPCSparseArrays
 using MultiGridBarrier
 using LinearAlgebra
 using SparseArrays

src/MultiGridBarrierMPI.jl

@@ -2,7 +2,7 @@
     MultiGridBarrierMPI
 
 A module that provides a convenient interface for using MultiGridBarrier with MPI
-distributed types through HPCLinearAlgebra.
+distributed types through HPCSparseArrays.
 
 # Exports
 - `fem1d_mpi`: Creates an MPI-based Geometry from fem1d parameters
@@ -44,24 +44,24 @@ sol_native = mpi_to_native(sol)
 module MultiGridBarrierMPI
 
 using MPI
-using HPCLinearAlgebra
-using HPCLinearAlgebra: HPCVector, HPCMatrix, HPCSparseMatrix, io0
-using HPCLinearAlgebra: HPCVector_local, HPCMatrix_local, HPCSparseMatrix_local
-using HPCLinearAlgebra: HPCBackend, backend_cpu_mpi, eltype_backend, indextype_backend
+using HPCSparseArrays
+using HPCSparseArrays: HPCVector, HPCMatrix, HPCSparseMatrix, io0
+using HPCSparseArrays: HPCVector_local, HPCMatrix_local, HPCSparseMatrix_local
+using HPCSparseArrays: HPCBackend, backend_cpu_mpi, eltype_backend, indextype_backend
 using LinearAlgebra
 using SparseArrays
 using MultiGridBarrier
 using MultiGridBarrier: Geometry, AMGBSOL, ParabolicSOL, fem1d, FEM1D, fem3d, FEM3D, parabolic_solve, amgb
 using PrecompileTools
 
 # ============================================================================
-# MultiGridBarrier API Implementation for HPCLinearAlgebra Types
+# MultiGridBarrier API Implementation for HPCSparseArrays Types
 # ============================================================================
 
 # Import the functions we need to extend
 import MultiGridBarrier: amgb_zeros, amgb_all_isfinite, amgb_diag, amgb_blockdiag, map_rows, map_rows_gpu, vertex_indices, _raw_array, _to_cpu_array, _rows_to_svectors
 
-# amgb_zeros: Create distributed zero matrices/vectors using Base.zeros from HPCLinearAlgebra
+# amgb_zeros: Create distributed zero matrices/vectors using Base.zeros from HPCSparseArrays
 # New API: zeros(T, Ti, HPCSparseMatrix, backend, m, n) - extract backend from existing matrix
 MultiGridBarrier.amgb_zeros(A::HPCSparseMatrix{T,Ti,B}, m, n) where {T,Ti,B} =
     zeros(T, Ti, HPCSparseMatrix, A.backend, m, n)
@@ -77,7 +77,7 @@ MultiGridBarrier.amgb_zeros(A::LinearAlgebra.Adjoint{T, <:HPCMatrix{T,B}}, m, n)
 # amgb_zeros for vectors (used in multigrid coarsening)
 # New API: zeros(T, HPCVector, backend, m) - need to map backend type to instance
 # This is a bit hacky but works for the known backend types
-using HPCLinearAlgebra: backend_cpu_serial
+using HPCSparseArrays: backend_cpu_serial
 
 # Cache for GPU backend instances (created lazily when needed)
 # Key: (T, Ti) -> backend instance
@@ -89,23 +89,23 @@ function _backend_instance_from_type(::Type{B}) where B
     Ti = B.parameters[2]
     device_type = B.parameters[3]
 
-    if device_type === HPCLinearAlgebra.DeviceCPU
+    if device_type === HPCSparseArrays.DeviceCPU
         comm_type = B.parameters[4]
-        if comm_type === HPCLinearAlgebra.CommSerial
+        if comm_type === HPCSparseArrays.CommSerial
             return backend_cpu_serial(T, Ti)
         else
             return backend_cpu_mpi(T, Ti)
         end
-    elseif device_type === HPCLinearAlgebra.DeviceCUDA
+    elseif device_type === HPCSparseArrays.DeviceCUDA
         cache_key = (T, Ti, device_type)
         if !haskey(_GPU_BACKEND_CACHE, cache_key)
-            _GPU_BACKEND_CACHE[cache_key] = HPCLinearAlgebra.backend_cuda_mpi(T, Ti)
+            _GPU_BACKEND_CACHE[cache_key] = HPCSparseArrays.backend_cuda_mpi(T, Ti)
         end
         return _GPU_BACKEND_CACHE[cache_key]
-    elseif device_type === HPCLinearAlgebra.DeviceMetal
+    elseif device_type === HPCSparseArrays.DeviceMetal
         cache_key = (T, Ti, device_type)
         if !haskey(_GPU_BACKEND_CACHE, cache_key)
-            _GPU_BACKEND_CACHE[cache_key] = HPCLinearAlgebra.backend_metal_mpi(T, Ti)
+            _GPU_BACKEND_CACHE[cache_key] = HPCSparseArrays.backend_metal_mpi(T, Ti)
         end
         return _GPU_BACKEND_CACHE[cache_key]
     else
@@ -149,24 +149,24 @@ MultiGridBarrier.amgb_diag(A::HPCMatrix{T,B}, z::Vector{T}, m=length(z), n=lengt
 # amgb_blockdiag: Block diagonal concatenation
 MultiGridBarrier.amgb_blockdiag(args::HPCSparseMatrix{T,Ti,AV}...) where {T,Ti,AV} = blockdiag(args...)
 
-# map_rows and map_rows_gpu: Delegate to HPCLinearAlgebra implementations
+# map_rows and map_rows_gpu: Delegate to HPCSparseArrays implementations
 # Use AbstractHPCVector/AbstractHPCMatrix union types for clean dispatch
 
 const AbstractHPCVector = HPCVector
 const AbstractHPCMatrix = Union{HPCMatrix, HPCSparseMatrix}
 const AnyMPI = Union{HPCVector, HPCMatrix, HPCSparseMatrix}
 
 # map_rows: single method that handles all MPI combinations
-# The key insight: if ANY argument is an MPI type, delegate to HPCLinearAlgebra
+# The key insight: if ANY argument is an MPI type, delegate to HPCSparseArrays
 function MultiGridBarrier.map_rows(f, A::AnyMPI, args...)
-    HPCLinearAlgebra.map_rows(f, A, args...)
+    HPCSparseArrays.map_rows(f, A, args...)
 end
 
-# map_rows_gpu: True GPU execution via HPCLinearAlgebra.map_rows_gpu
+# map_rows_gpu: True GPU execution via HPCSparseArrays.map_rows_gpu
 # Barrier functions now receive row data via broadcasting (no scalar indexing)
 # thanks to Q.args being splatted here. This enables true GPU kernel execution.
 function MultiGridBarrier.map_rows_gpu(f, A::AnyMPI, args...)
-    HPCLinearAlgebra.map_rows_gpu(f, A, args...)  # True GPU path
+    HPCSparseArrays.map_rows_gpu(f, A, args...)  # True GPU path
 end
 
 # _raw_array: Extract raw array from MPI wrappers
@@ -188,8 +188,8 @@ MultiGridBarrier._to_cpu_array(x::HPCMatrix) = Array(x.A)
 MultiGridBarrier._to_cpu_array(x::HPCVector) = Array(x.v)
 
 # vertex_indices for MPI types
-MultiGridBarrier.vertex_indices(A::HPCVector) = HPCLinearAlgebra.vertex_indices(A)
-MultiGridBarrier.vertex_indices(A::HPCMatrix) = HPCLinearAlgebra.vertex_indices(A)
+MultiGridBarrier.vertex_indices(A::HPCVector) = HPCSparseArrays.vertex_indices(A)
+MultiGridBarrier.vertex_indices(A::HPCMatrix) = HPCSparseArrays.vertex_indices(A)
 
 # ============================================================================
 # Type Conversion