Use verbosity system

docs/src/advanced/developing.md

@@ -19,7 +19,7 @@ struct MyLUFactorization{P} <: LinearSolve.SciMLLinearSolveAlgorithm end
 
 function LinearSolve.init_cacheval(
         alg::MyLUFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol,
-        verbose::Bool, assump::LinearSolve.OperatorAssumptions)
+        verbose::LinearVerbosity, assump::LinearSolve.OperatorAssumptions)
     lu!(convert(AbstractMatrix, A))
 end
 

ext/LinearSolveBandedMatricesExt.jl

@@ -41,14 +41,14 @@ for alg in (:SVDFactorization, :MKLLUFactorization, :DiagonalFactorization,
     :AppleAccelerateLUFactorization, :CholeskyFactorization)
     @eval begin
         function init_cacheval(::$(alg), ::BandedMatrix, b, u, Pl, Pr, maxiters::Int,
-                abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
+                abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions)
             return nothing
         end
     end
 end
 
 function init_cacheval(::LUFactorization, A::BandedMatrix{T}, b, u, Pl, Pr, maxiters::Int,
-        abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) where {T}
+        abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T}
     (T <: BigFloat) && return qr(similar(A, 0, 0))
     return lu(similar(A, 0, 0))
 end
@@ -61,7 +61,7 @@ for alg in (:SVDFactorization, :MKLLUFactorization, :DiagonalFactorization,
     :AppleAccelerateLUFactorization, :QRFactorization, :LUFactorization)
     @eval begin
         function init_cacheval(::$(alg), ::Symmetric{<:Number, <:BandedMatrix}, b, u, Pl,
-                Pr, maxiters::Int, abstol, reltol, verbose::Bool,
+                Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity,
                 assumptions::OperatorAssumptions)
             return nothing
         end

ext/LinearSolveCUDAExt.jl

@@ -38,26 +38,26 @@ function SciMLBase.solve!(cache::LinearSolve.LinearCache, alg::CudaOffloadFactor
 end
 
 function LinearSolve.init_cacheval(alg::CudaOffloadFactorization, A, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::LinearVerbosity,
         assumptions::OperatorAssumptions)
     qr(CUDA.CuArray(A))
 end
 
 function LinearSolve.init_cacheval(
         ::SparspakFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u,
-        Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
+        Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions)
     nothing
 end
 
 function LinearSolve.init_cacheval(
         ::KLUFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u,
-        Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
+        Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions)
     nothing
 end
 
 function LinearSolve.init_cacheval(
         ::UMFPACKFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u,
-        Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
+        Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions)
     nothing
 end
 

ext/LinearSolveFastAlmostBandedMatricesExt.jl

@@ -21,7 +21,7 @@ for alg in (:SVDFactorization, :MKLLUFactorization, :DiagonalFactorization,
     :AppleAccelerateLUFactorization, :CholeskyFactorization, :LUFactorization)
     @eval begin
         function init_cacheval(::$(alg), ::AlmostBandedMatrix, b, u, Pl, Pr, maxiters::Int,
-                abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
+                abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions)
             return nothing
         end
     end

ext/LinearSolveFastLapackInterfaceExt.jl

@@ -9,7 +9,7 @@ struct WorkspaceAndFactors{W, F}
 end
 
 function LinearSolve.init_cacheval(::FastLUFactorization, A, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::LinearVerbosity,
         assumptions::OperatorAssumptions)
     ws = LUWs(A)
     return WorkspaceAndFactors(
@@ -36,26 +36,26 @@ end
 
 function LinearSolve.init_cacheval(
         alg::FastQRFactorization{NoPivot}, A::AbstractMatrix, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::LinearVerbosity,
         assumptions::OperatorAssumptions)
     ws = QRWYWs(A; blocksize = alg.blocksize)
     return WorkspaceAndFactors(ws,
         LinearSolve.ArrayInterface.qr_instance(convert(AbstractMatrix, A)))
 end
 function LinearSolve.init_cacheval(
         ::FastQRFactorization{ColumnNorm}, A::AbstractMatrix, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::LinearVerbosity,
         assumptions::OperatorAssumptions)
     ws = QRpWs(A)
     return WorkspaceAndFactors(ws,
         LinearSolve.ArrayInterface.qr_instance(convert(AbstractMatrix, A)))
 end
 
 function LinearSolve.init_cacheval(alg::FastQRFactorization, A, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::LinearVerbosity,
         assumptions::OperatorAssumptions)
     return init_cacheval(alg, convert(AbstractMatrix, A), b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::LinearVerbosity,
         assumptions::OperatorAssumptions)
 end
 

ext/LinearSolveHYPREExt.jl

@@ -22,7 +22,7 @@ end
 
 function LinearSolve.init_cacheval(alg::HYPREAlgorithm, A, b, u, Pl, Pr, maxiters::Int,
         abstol, reltol,
-        verbose::Bool, assumptions::OperatorAssumptions)
+        verbose::LinearVerbosity, assumptions::OperatorAssumptions)
     return HYPRECache(nothing, nothing, nothing, nothing, true, true, true)
 end
 
@@ -64,7 +64,7 @@ function SciMLBase.init(prob::LinearProblem, alg::HYPREAlgorithm,
                              eltype(prob.A)),
         # TODO: Implement length() for HYPREVector in HYPRE.jl?
         maxiters::Int = prob.b isa HYPREVector ? 1000 : length(prob.b),
-        verbose::Bool = false,
+        verbose::LinearVerbosity = false,
         Pl = LinearAlgebra.I,
         Pr = LinearAlgebra.I,
         assumptions = OperatorAssumptions(),

ext/LinearSolveIterativeSolversExt.jl

@@ -51,7 +51,7 @@ LinearSolve.default_alias_b(::IterativeSolversJL, ::Any, ::Any) = true
 function LinearSolve.init_cacheval(alg::IterativeSolversJL, A, b, u, Pl, Pr, maxiters::Int,
         abstol,
         reltol,
-        verbose::Bool, assumptions::OperatorAssumptions)
+        verbose::LinearVerbosity, assumptions::OperatorAssumptions)
     restart = (alg.gmres_restart == 0) ? min(20, size(A, 1)) : alg.gmres_restart
     s = :idrs_s in keys(alg.kwargs) ? alg.kwargs.idrs_s : 4 # shadow space
 
@@ -60,23 +60,26 @@ function LinearSolve.init_cacheval(alg::IterativeSolversJL, A, b, u, Pl, Pr, max
 
     iterable = if alg.generate_iterator === IterativeSolvers.cg_iterator!
         !LinearSolve._isidentity_struct(Pr) &&
-            @warn "$(alg.generate_iterator) doesn't support right preconditioning"
+            @SciMLMessage("$(alg.generate_iterator) doesn't support right preconditioning",
+                verbose, :no_right_preconditioning, :performance)
         alg.generate_iterator(u, A, b, Pl;
             kwargs...)
     elseif alg.generate_iterator === IterativeSolvers.gmres_iterable!
         alg.generate_iterator(u, A, b; Pl = Pl, Pr = Pr, restart = restart,
             kwargs...)
     elseif alg.generate_iterator === IterativeSolvers.idrs_iterable!
         !!LinearSolve._isidentity_struct(Pr) &&
-            @warn "$(alg.generate_iterator) doesn't support right preconditioning"
+            @SciMLMessage("$(alg.generate_iterator) doesn't support right preconditioning", 
+                verbose, :no_right_preconditioning, :performance)
         history = IterativeSolvers.ConvergenceHistory(partial = true)
         history[:abstol] = abstol
         history[:reltol] = reltol
         IterativeSolvers.idrs_iterable!(history, u, A, b, s, Pl, abstol, reltol, maxiters;
             alg.kwargs...)
     elseif alg.generate_iterator === IterativeSolvers.bicgstabl_iterator!
         !!LinearSolve._isidentity_struct(Pr) &&
-            @warn "$(alg.generate_iterator) doesn't support right preconditioning"
+            @SciMLMessage("$(alg.generate_iterator) doesn't support right preconditioning",
+                verbose, :no_right_preconditioning, :performance)
         alg.generate_iterator(u, A, b, alg.args...; Pl = Pl,
             abstol = abstol, reltol = reltol,
             max_mv_products = maxiters * 2,
@@ -107,14 +110,13 @@ function SciMLBase.solve!(cache::LinearCache, alg::IterativeSolversJL; kwargs...
     end
     purge_history!(cache.cacheval, cache.u, cache.b)
 
-    cache.verbose && println("Using IterativeSolvers.$(alg.generate_iterator)")
+    @SciMLMessage("Using IterativeSolvers.$(alg.generate_iterator)", cache.verbose, :using_IterativeSolvers, :numerical)
     i = 0
     for iter in enumerate(cache.cacheval)
         i += 1
-        cache.verbose && println("Iter: $(iter[1]), residual: $(iter[2])")
+        @SciMLMessage("Iter: $(iter[1]), residual: $(iter[2])", cache.verbose, :IterativeSolvers_iterations)
         # TODO inject callbacks KSP into solve! cb!(cache.cacheval)
     end
-    cache.verbose && println()
 
     resid = cache.cacheval isa IterativeSolvers.IDRSIterable ? cache.cacheval.R :
             cache.cacheval.residual

ext/LinearSolveKrylovKitExt.jl

@@ -26,6 +26,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovKitJL; kwargs...)
     rtol = float(cache.reltol)
     maxiter = cache.maxiters
     verbosity = cache.verbose ? 1 : 0
+    verbosity = verbosity_to_KrylovKit(cache.verbose.numerical.Krylovkit_verbosity)
     krylovdim = (alg.gmres_restart == 0) ? min(20, size(cache.A, 1)) : alg.gmres_restart
 
     kwargs = (atol = atol, rtol = rtol, maxiter = maxiter, verbosity = verbosity,
@@ -41,4 +42,13 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovKitJL; kwargs...)
         iters = iters)
 end
 
+function verbosity_to_KrylovKit(verb::SciMLBase.Verbosity.Type)
+    SciML.@match verb begin
+        Verbosity.None() => 0
+        Verbosity.Warn() => 1
+        Verbosity.Error() => 2
+        Verbosity.Info() => 3
+        Level(x) => x
+        _ => error("Not a valid verbosity level for KrylovKit.")
+    end
 end

ext/LinearSolveMetalExt.jl

@@ -9,7 +9,7 @@ default_alias_A(::MetalLUFactorization, ::Any, ::Any) = false
 default_alias_b(::MetalLUFactorization, ::Any, ::Any) = false
 
 function LinearSolve.init_cacheval(alg::MetalLUFactorization, A, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::LinearVerbosity,
         assumptions::OperatorAssumptions)
     ArrayInterface.lu_instance(convert(AbstractMatrix, A))
 end

ext/LinearSolvePardisoExt.jl

@@ -21,7 +21,7 @@ function LinearSolve.init_cacheval(alg::PardisoJL,
         maxiters::Int,
         abstol,
         reltol,
-        verbose::Bool,
+        verbose::LinearVerbosity,
         assumptions::LinearSolve.OperatorAssumptions)
     @unpack nprocs, solver_type, matrix_type, cache_analysis, iparm, dparm, vendor = alg
     A = convert(AbstractMatrix, A)