new module ModCompressedLBFGSOperator + remove CUDA + add Requires + fix

doc

Author: RAYNAUD Paul (raynaudp)

Project.toml

@@ -3,18 +3,18 @@ uuid = "5c8ed15e-5a4c-59e4-a42b-c7e8811fb125"
 version = "2.5.1"
 
 [deps]
-CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
 FastClosures = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a"
 LDLFactorizations = "40e66cde-538c-5869-a4ad-c39174c6795b"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 TimerOutputs = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f"
 
 [compat]
-CUDA = "3.12.1"
 FastClosures = "0.2, 0.3"
 LDLFactorizations = "0.9, 0.10"
+Requires = "1.3"
 TimerOutputs = "^0.5"
 julia = "^1.6.0"
 

docs/make.jl

@@ -1,4 +1,5 @@
 using Documenter, LinearOperators
+using LinearOperators.ModCompressedLBFGSOperator
 
 makedocs(
   modules = [LinearOperators],

docs/src/reference.md

@@ -13,5 +13,5 @@ Pages = ["reference.md"]
 ```
 
 ```@autodocs
-Modules = [LinearOperators]
+Modules = [LinearOperators, ModCompressedLBFGSOperator]
 ```

src/compressed_lbfgs.jl

@@ -1,3 +1,4 @@
+module ModCompressedLBFGSOperator
 #=
 Compressed LBFGS implementation from:
     REPRESENTATIONS OF QUASI-NEWTON MATRICES AND THEIR USE IN LIMITED MEMORY METHODS
@@ -8,9 +9,21 @@ Implemented by Paul Raynaud (supervised by Dominique Orban)
 =#
 
 using LinearAlgebra, LinearAlgebra.BLAS
-using CUDA
+using Requires
+
+default_matrix_type(; T::DataType=Float64) = Matrix{T}
+default_vector_type(; T::DataType=Float64) = Vector{T}
+
+@init begin
+  @require CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" begin
+    default_matrix_type(; T::DataType=Float64) = CUDA.CuMatrix{T}
+    default_vector_type(; T::DataType=Float64) = CUDA.CuVector{T}
+  end
+  # this scheme may be extended to other GPU modules
+end
 
 export CompressedLBFGSOperator
+export default_matrix_type, default_vector_type
 
 """
     CompressedLBFGSOperator{T, M<:AbstractMatrix{T}, V<:AbstractVector{T}}
@@ -58,10 +71,6 @@ mutable struct CompressedLBFGSOperator{T, M<:AbstractMatrix{T}, V<:AbstractVecto
   sol::V # mem
 end
 
-default_gpu() = CUDA.functional() ? true : false
-default_matrix_type(gpu::Bool; T::DataType=Float64) = gpu ? CuMatrix{T} : Matrix{T}
-default_vector_type(gpu::Bool; T::DataType=Float64) = gpu ? CuVector{T} : Vector{T}
-
 function columnshift!(A::AbstractMatrix{T}; direction::Int=-1, indicemax::Int=size(A)[1]) where T
   map(i-> view(A,:,i+direction) .= view(A,:,i), 1-direction:indicemax)
   return A
@@ -78,7 +87,7 @@ end
 A implementation of a LBFGS operator (forward), representing a `nxn` linear application.
 It considers at most `k` BFGS iterates, and fit the architecture depending if it is launched on a CPU or a GPU.
 """
-function CompressedLBFGSOperator(n::Int; mem::Int=5, T=Float64, gpu=default_gpu(), M=default_matrix_type(gpu; T), V=default_vector_type(gpu; T))
+function CompressedLBFGSOperator(n::Int; mem::Int=5, T=Float64, M=default_matrix_type(; T), V=default_vector_type(; T))
   α = (T)(1)
   k = 0  
   Sₖ = M(undef, n, mem)
@@ -203,4 +212,10 @@ function LinearAlgebra.mul!(Bv::V, op::CompressedLBFGSOperator{T,M,V}, v::V) whe
   mul!(Bv, view(op.Sₖ, :, 1:op.k), view(op.sol, op.k+1:2*op.k), - op.α, (T)(-1))
   Bv .+= op.α .* v 
   return Bv
-end
+end
+
+end
+
+using ..ModCompressedLBFGSOperator
+export CompressedLBFGSOperator
+export default_matrix_type, default_vector_type

test/gpu/nvidia.jl

@@ -14,3 +14,5 @@ using LinearOperators, CUDA, CUDA.CUSPARSE, CUDA.CUSOLVER
   y = M * v
   @test y isa CuVector{Float32}
 end
+
+include("../test_clbfgs.jl")

test/test_clbfgs.jl

@@ -3,7 +3,7 @@
   n=100
   n=5
   lbfgs = CompressedLBFGSOperator(n) # m=5
-  V = LinearOperators.default_vector_type(LinearOperators.default_gpu())
+  V = LinearOperators.default_vector_type()
   Bv = V(rand(n))
   s = V(rand(n))
   mul!(Bv, lbfgs, s) # warm-up