Merge branch 'SciML:main' into dev

Author: AstitvaAggarwal

Project.toml

@@ -1,7 +1,7 @@
 name = "LinearSolve"
 uuid = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae"
 authors = ["SciML"]
-version = "3.44.0"
+version = "3.46.1"
 
 [deps]
 ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
@@ -23,9 +23,11 @@ Preferences = "21216c6a-2e73-6563-6e65-726566657250"
 RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
+SciMLLogging = "a6db7da4-7206-11f0-1eab-35f2a5dbe1d1"
 SciMLOperators = "c0aeaf25-5076-4817-a8d5-81caf7dfa961"
 Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46"
 StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c"
+TriangularSolve = "d5829a12-d9aa-46ab-831f-fb7c9ab06edf"
 UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
 
 [weakdeps]
@@ -85,11 +87,12 @@ ArrayInterface = "7.17"
 BandedMatrices = "1.8"
 BlockDiagonals = "0.2"
 CUDA = "5.5"
-CUDSS = "0.4"
+CUDSS = "0.4, 0.6.1"
 CUSOLVERRF = "0.2.6"
 ChainRulesCore = "1.25"
 CliqueTrees = "1.11.0"
 ConcreteStructs = "0.2.3"
+ComponentArrays = "0.15.29"
 DocStringExtensions = "0.9.3"
 EnumX = "1.0.4"
 EnzymeCore = "0.8.5"
@@ -123,18 +126,20 @@ PrecompileTools = "1.2"
 Preferences = "1.4"
 Random = "1.10"
 RecursiveArrayTools = "3.37"
-RecursiveFactorization = "0.2.23"
+RecursiveFactorization = "0.2.26"
 Reexport = "1.2.2"
 SafeTestsets = "0.1"
 SciMLBase = "2.70"
 SciMLOperators = "1.7.1"
+SciMLLogging = "1.3.1"
 Setfield = "1.1.1"
 SparseArrays = "1.10"
 Sparspak = "0.3.9"
 StableRNGs = "1.0"
 StaticArrays = "1.9"
 StaticArraysCore = "1.4.3"
 Test = "1.10"
+TriangularSolve = "0.2.1"
 UnPack = "1.0.2"
 Zygote = "0.7"
 blis_jll = "0.9.0"
@@ -146,6 +151,7 @@ Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
 BlockDiagonals = "0a1fb500-61f7-11e9-3c65-f5ef3456f9f0"
 CliqueTrees = "60701a23-6482-424a-84db-faee86b9b1f8"
+ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66"
 ExplicitImports = "7d51a73a-1435-4ff3-83d9-f097790105c7"
 FastAlmostBandedMatrices = "9d29842c-ecb8-4973-b1e9-a27b1157504e"
 FastLapackInterface = "29a986be-02c6-4525-aec4-84b980013641"
@@ -174,4 +180,4 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [targets]
-test = ["Aqua", "Test", "IterativeSolvers", "InteractiveUtils", "KrylovKit", "KrylovPreconditioners", "Pkg", "Random", "SafeTestsets", "MultiFloats", "ForwardDiff", "HYPRE", "MPI", "BlockDiagonals", "FiniteDiff", "BandedMatrices", "FastAlmostBandedMatrices", "StaticArrays", "AllocCheck", "StableRNGs", "Zygote", "RecursiveFactorization", "Sparspak", "CliqueTrees", "FastLapackInterface", "SparseArrays", "ExplicitImports"]
+test = ["Aqua", "Test", "IterativeSolvers", "InteractiveUtils", "KrylovKit", "KrylovPreconditioners", "Pkg", "Random", "SafeTestsets", "MultiFloats", "ForwardDiff", "HYPRE", "MPI", "BlockDiagonals", "FiniteDiff", "BandedMatrices", "FastAlmostBandedMatrices", "StaticArrays", "AllocCheck", "StableRNGs", "Zygote", "RecursiveFactorization", "Sparspak", "CliqueTrees", "FastLapackInterface", "SparseArrays", "ExplicitImports", "ComponentArrays"]

benchmarks/lu.jl

@@ -1,7 +1,8 @@
 using BenchmarkTools, Random, VectorizationBase
 using LinearAlgebra, LinearSolve, MKL_jll
+using RecursiveFactorization
+
 nc = min(Int(VectorizationBase.num_cores()), Threads.nthreads())
-BLAS.set_num_threads(nc)
 BenchmarkTools.DEFAULT_PARAMETERS.seconds = 0.5
 
 function luflop(m, n = m; innerflop = 2)
@@ -24,10 +25,10 @@ algs = [
     RFLUFactorization(),
     MKLLUFactorization(),
     FastLUFactorization(),
-    SimpleLUFactorization()
+    SimpleLUFactorization(),
+    ButterflyFactorization(Val(true))
 ]
 res = [Float64[] for i in 1:length(algs)]
-
 ns = 4:8:500
 for i in 1:length(ns)
     n = ns[i]
@@ -65,3 +66,4 @@ p
 
 savefig("lubench.png")
 savefig("lubench.pdf")
+

docs/src/basics/common_solver_opts.md

@@ -26,3 +26,69 @@ solve completely. Error controls only apply to iterative solvers.
   - `maxiters`: The number of iterations allowed. Defaults to `length(prob.b)`
   - `Pl,Pr`: The left and right preconditioners, respectively. For more information,
     see [the Preconditioners page](@ref prec).
+
+## Verbosity Controls
+
+The verbosity system in LinearSolve.jl provides fine-grained control over the diagnostic messages, warnings, and errors that are displayed during the solution of linear systems. To use this system, a keyword argument `verbose` is provided to `solve`. 
+
+```@docs
+LinearVerbosity
+```
+
+### Basic Usage 
+
+#### Global Verbosity Control
+
+```julia
+using LinearSolve
+
+# Suppress all messages
+verbose = LinearVerbosity(SciMLLogging.None())
+prob = LinearProblem(A, b)
+sol = solve(prob; verbose=verbose)
+
+# Show only essential messages (critical errors and fatal issues)
+verbose = LinearVerbosity(SciMLLogging.Minimal())
+sol = solve(prob; verbose=verbose)
+
+# Use default settings (balanced verbosity for typical usage)
+verbose = LinearVerbosity(SciMLLogging.Standard())
+sol = solve(prob; verbose=verbose)
+
+# Show comprehensive debugging information
+verbose = LinearVerbosity(SciMLLogging.Detailed())
+sol = solve(prob; verbose=verbose)
+
+# Show all messages (maximum verbosity)
+verbose = LinearVerbosity(SciMLLogging.All())
+sol = solve(prob; verbose=verbose)
+```
+
+#### Group Level Control 
+
+```julia 
+# Customize by category
+verbose = LinearVerbosity(
+    error_control = SciMLLogging.Warn(),   # Show warnings for error control related issues
+    performance = SciMLLogging.Silent(),     # Suppress performance messages
+    numerical = SciMLLogging.Info()        # Show all numerical related log messages at info level
+)
+
+sol = solve(prob; verbose=verbose)
+```
+
+#### Fine-grained Control
+The constructor for `LinearVerbosity` allows you to set verbosity for each specific message toggle, giving you fine-grained control. 
+The verbosity settings for the toggles are automatically passed to the group objects. 
+```julia
+# Set specific message types
+verbose = LinearVerbosity(
+    default_lu_fallback = SciMLLogging.InfoLevel(),                     # Show info when LU fallback is used
+    KrylovJL_verbosity = SciMLLogging.WarnLevel(),                      # Show warnings from KrylovJL
+    no_right_preconditioning = SciMLLogging.Silent(),                # Suppress right preconditioning messages
+    KrylovKit_verbosity = SciMLLogging.Level(KrylovKit.WARN_LEVEL) # Set KrylovKit verbosity level using KrylovKit's own verbosity levels
+)
+
+sol = solve(prob; verbose=verbose)
+
+```

ext/LinearSolveAMDGPUExt.jl

@@ -2,7 +2,7 @@ module LinearSolveAMDGPUExt
 
 using AMDGPU
 using LinearSolve: LinearSolve, LinearCache, AMDGPUOffloadLUFactorization,
-                   AMDGPUOffloadQRFactorization, init_cacheval, OperatorAssumptions
+                   AMDGPUOffloadQRFactorization, init_cacheval, OperatorAssumptions, LinearVerbosity
 using LinearSolve.LinearAlgebra, LinearSolve.SciMLBase
 
 # LU Factorization
@@ -25,7 +25,7 @@ function SciMLBase.solve!(cache::LinearSolve.LinearCache, alg::AMDGPUOffloadLUFa
 end
 
 function LinearSolve.init_cacheval(alg::AMDGPUOffloadLUFactorization, A, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::Union{LinearVerbosity, Bool},
         assumptions::OperatorAssumptions)
     AMDGPU.rocSOLVER.getrf!(AMDGPU.ROCArray(A))
 end
@@ -57,7 +57,7 @@ function SciMLBase.solve!(cache::LinearSolve.LinearCache, alg::AMDGPUOffloadQRFa
 end
 
 function LinearSolve.init_cacheval(alg::AMDGPUOffloadQRFactorization, A, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::Union{LinearVerbosity, Bool},
         assumptions::OperatorAssumptions)
     A_gpu = AMDGPU.ROCArray(A)
     tau = AMDGPU.ROCVector{eltype(A_gpu)}(undef, min(size(A_gpu)...))

ext/LinearSolveBLISExt.jl

@@ -9,7 +9,8 @@ using LinearSolve
 using LinearAlgebra: BlasInt, LU
 using LinearAlgebra.LAPACK: require_one_based_indexing, chkfinite, chkstride1, 
                             @blasfunc, chkargsok
-using LinearSolve: ArrayInterface, BLISLUFactorization, @get_cacheval, LinearCache, SciMLBase
+using LinearSolve: ArrayInterface, BLISLUFactorization, @get_cacheval, LinearCache, SciMLBase, LinearVerbosity, get_blas_operation_info, blas_info_msg
+using SciMLLogging: SciMLLogging, @SciMLMessage
 using SciMLBase: ReturnCode
 
 const global libblis = blis_jll.blis
@@ -206,13 +207,13 @@ const PREALLOCATED_BLIS_LU = begin
 end
 
 function LinearSolve.init_cacheval(alg::BLISLUFactorization, A::Matrix{Float64}, b, u, Pl, Pr,
-    maxiters::Int, abstol, reltol, verbose::Bool,
+    maxiters::Int, abstol, reltol, verbose::Union{LinearVerbosity, Bool},
     assumptions::OperatorAssumptions)
     PREALLOCATED_BLIS_LU
 end
 
 function LinearSolve.init_cacheval(alg::BLISLUFactorization, A::AbstractMatrix{<:Union{Float32,ComplexF32,ComplexF64}}, b, u, Pl, Pr,
-    maxiters::Int, abstol, reltol, verbose::Bool,
+    maxiters::Int, abstol, reltol, verbose::Union{LinearVerbosity, Bool},
     assumptions::OperatorAssumptions)
     A = rand(eltype(A), 0, 0)
     ArrayInterface.lu_instance(A), Ref{BlasInt}()
@@ -222,13 +223,47 @@ function SciMLBase.solve!(cache::LinearCache, alg::BLISLUFactorization;
     kwargs...)
     A = cache.A
     A = convert(AbstractMatrix, A)
+    verbose = cache.verbose
     if cache.isfresh
         cacheval = @get_cacheval(cache, :BLISLUFactorization)
         res = getrf!(A; ipiv = cacheval[1].ipiv, info = cacheval[2])
         fact = LU(res[1:3]...), res[4]
         cache.cacheval = fact
 
+        info_value = res[3]
+
+        if info_value != 0
+            if !isa(verbose.blas_info, SciMLLogging.Silent) || !isa(verbose.blas_errors, SciMLLogging.Silent) ||
+                !isa(verbose.blas_invalid_args, SciMLLogging.Silent) 
+                op_info = get_blas_operation_info(:dgetrf, A, cache.b, condition = !isa(verbose.condition_number, SciMLLogging.Silent))
+                @SciMLMessage(cache.verbose, :condition_number) do 
+                    if op_info[:condition_number] === nothing
+                        return "Matrix condition number calculation failed."
+                    else 
+                        return "Matrix condition number: $(round(op_info[:condition_number], sigdigits=4)) for $(size(A, 1))×$(size(A, 2)) matrix in dgetrf"
+                    end
+                end
+                verb_option, message = blas_info_msg(
+                    :dgetrf, info_value; extra_context = op_info)
+                @SciMLMessage(message, verbose, verb_option)
+            end
+        else
+            @SciMLMessage(cache.verbose, :blas_success) do 
+                op_info = get_blas_operation_info(:dgetrf, A, cache.b,
+                    condition = !isa(verbose.condition_number, SciMLLogging.Silent))
+                @SciMLMessage(cache.verbose, :condition_number) do
+                    if op_info[:condition_number] === nothing
+                        return "Matrix condition number calculation failed."
+                    else
+                        return "Matrix condition number: $(round(op_info[:condition_number], sigdigits=4)) for $(size(A, 1))×$(size(A, 2)) matrix in dgetrf"
+                    end
+                end
+                return "BLAS LU factorization (dgetrf) completed successfully for $(op_info[:matrix_size]) matrix"
+            end 
+        end
+
         if !LinearAlgebra.issuccess(fact[1])
+            @SciMLMessage("Solver failed", cache.verbose, :solver_failure)
             return SciMLBase.build_linear_solution(
                 alg, cache.u, nothing, cache; retcode = ReturnCode.Failure)
         end

ext/LinearSolveBandedMatricesExt.jl

@@ -3,7 +3,7 @@ module LinearSolveBandedMatricesExt
 using BandedMatrices, LinearAlgebra, LinearSolve
 import LinearSolve: defaultalg,
                     do_factorization, init_cacheval, DefaultLinearSolver,
-                    DefaultAlgorithmChoice
+                    DefaultAlgorithmChoice, LinearVerbosity
 
 # Defaults for BandedMatrices
 function defaultalg(A::BandedMatrix, b, oa::OperatorAssumptions{Bool})
@@ -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::Union{LinearVerbosity, Bool}, 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::Union{LinearVerbosity, Bool}, 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::Union{LinearVerbosity, Bool},
                 assumptions::OperatorAssumptions)
             return nothing
         end

ext/LinearSolveCUDAExt.jl

@@ -7,7 +7,7 @@ using LinearSolve: LinearSolve, is_cusparse, defaultalg, cudss_loaded, DefaultLi
                    error_no_cudss_lu, init_cacheval, OperatorAssumptions,
                    CudaOffloadFactorization, CudaOffloadLUFactorization, CudaOffloadQRFactorization,
                    CUDAOffload32MixedLUFactorization,
-                   SparspakFactorization, KLUFactorization, UMFPACKFactorization
+                   SparspakFactorization, KLUFactorization, UMFPACKFactorization, LinearVerbosity
 using LinearSolve.LinearAlgebra, LinearSolve.SciMLBase, LinearSolve.ArrayInterface
 using SciMLBase: AbstractSciMLOperator
 
@@ -53,7 +53,7 @@ function SciMLBase.solve!(cache::LinearSolve.LinearCache, alg::CudaOffloadLUFact
 end
 
 function LinearSolve.init_cacheval(alg::CudaOffloadLUFactorization, A::AbstractArray, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::Union{LinearVerbosity, Bool},
         assumptions::OperatorAssumptions)
     # Check if CUDA is functional before creating CUDA arrays
     if !CUDA.functional()
@@ -81,7 +81,7 @@ function SciMLBase.solve!(cache::LinearSolve.LinearCache, alg::CudaOffloadQRFact
 end
 
 function LinearSolve.init_cacheval(alg::CudaOffloadQRFactorization, A, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::Union{LinearVerbosity, Bool},
         assumptions::OperatorAssumptions)
     # Check if CUDA is functional before creating CUDA arrays
     if !CUDA.functional()
@@ -105,26 +105,26 @@ function SciMLBase.solve!(cache::LinearSolve.LinearCache, alg::CudaOffloadFactor
 end
 
 function LinearSolve.init_cacheval(alg::CudaOffloadFactorization, A::AbstractArray, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::Union{LinearVerbosity, Bool},
         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::Union{LinearVerbosity, Bool}, 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::Union{LinearVerbosity, Bool}, 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::Union{LinearVerbosity, Bool}, assumptions::OperatorAssumptions)
     nothing
 end
 
@@ -158,7 +158,7 @@ function SciMLBase.solve!(cache::LinearSolve.LinearCache, alg::CUDAOffload32Mixe
 end
 
 function LinearSolve.init_cacheval(alg::CUDAOffload32MixedLUFactorization, A, b, u, Pl, Pr,
-        maxiters::Int, abstol, reltol, verbose::Bool,
+        maxiters::Int, abstol, reltol, verbose::Union{LinearVerbosity, Bool},
         assumptions::OperatorAssumptions)
     # Pre-allocate with Float32 arrays
     m, n = size(A)

ext/LinearSolveCUSOLVERRFExt.jl

@@ -10,15 +10,15 @@ using SciMLBase: SciMLBase, LinearProblem, ReturnCode
 function LinearSolve.init_cacheval(alg::LinearSolve.CUSOLVERRFFactorization,
         A, b, u, Pl, Pr,
         maxiters::Int, abstol, reltol,
-        verbose::Bool, assumptions::OperatorAssumptions)
+        verbose::Union{LinearVerbosity, Bool}, assumptions::OperatorAssumptions)
     nothing
 end
 
 function LinearSolve.init_cacheval(alg::LinearSolve.CUSOLVERRFFactorization,
         A::Union{CuSparseMatrixCSR{Float64, Int32}, SparseMatrixCSC{Float64, <:Integer}}, 
         b, u, Pl, Pr,
         maxiters::Int, abstol, reltol,
-        verbose::Bool, assumptions::OperatorAssumptions)
+        verbose::Union{LinearVerbosity, Bool}, assumptions::OperatorAssumptions)
     # Create initial factorization with appropriate options
     nrhs = b isa AbstractMatrix ? size(b, 2) : 1
     symbolic = alg.symbolic

ext/LinearSolveCliqueTreesExt.jl

@@ -22,7 +22,7 @@ end
 
 function LinearSolve.init_cacheval(
     alg::CliqueTreesFactorization, A::AbstractMatrix, b, u, Pl, Pr, maxiters::Int, abstol,
-    reltol, verbose::Bool, assumptions::OperatorAssumptions)
+    reltol, verbose::Union{LinearVerbosity, Bool}, assumptions::OperatorAssumptions)
     symbfact = _symbolic(A, alg)
     cholfact, cholwork = cholinit(A, symbfact)
     linwork = lininit(1, cholfact)