add blas logging for apple, mkl, openblas

Author: jClugstor

src/appleaccelerate.jl

@@ -255,12 +255,45 @@ function SciMLBase.solve!(cache::LinearCache, alg::AppleAccelerateLUFactorizatio
         error("Error, AppleAccelerate binary is missing but solve is being called. Report this issue")
     A = cache.A
     A = convert(AbstractMatrix, A)
+    verbose = cache.verbose
     if cache.isfresh
         cacheval = @get_cacheval(cache, :AppleAccelerateLUFactorization)
         res = aa_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])
             return SciMLBase.build_linear_solution(
                 alg, cache.u, nothing, cache; retcode = ReturnCode.Failure)

src/mkl.jl

@@ -239,12 +239,45 @@ function SciMLBase.solve!(cache::LinearCache, alg::MKLLUFactorization;
         error("Error, MKL binary is missing but solve is being called. Report this issue")
     A = cache.A
     A = convert(AbstractMatrix, A)
+    verbose = cache.verbose
     if cache.isfresh
         cacheval = @get_cacheval(cache, :MKLLUFactorization)
         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])
             return SciMLBase.build_linear_solution(
                 alg, cache.u, nothing, cache; retcode = ReturnCode.Failure)

src/openblas.jl

@@ -264,12 +264,45 @@ function SciMLBase.solve!(cache::LinearCache, alg::OpenBLASLUFactorization;
         error("Error, OpenBLAS binary is missing but solve is being called. Report this issue")
     A = cache.A
     A = convert(AbstractMatrix, A)
+    verbose = cache.verbose
     if cache.isfresh
         cacheval = @get_cacheval(cache, :OpenBLASLUFactorization)
         res = openblas_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])
             return SciMLBase.build_linear_solution(
                 alg, cache.u, nothing, cache; retcode = ReturnCode.Failure)

test/verbosity.jl

@@ -323,7 +323,7 @@ end
 @testset "BLIS Verbosity Integration Tests" begin
     @testset "BLIS solver with verbosity logging" begin
         # Test basic BLIS solver functionality with verbosity
-        if Base.get_extension(LinearSolve, :LinearSolveBLISExt) == nothing
+        if Base.get_extension(LinearSolve, :LinearSolveBLISExt) === nothing
             # Only test if BLIS is available
             @info "Skipping BLIS tests - BLIS not available"
         else
@@ -387,4 +387,220 @@ end
                 prob_good, BLISLUFactorization(); verbose = verbose_with_cond)
         end
     end
+end
+
+@testset "OpenBLAS Verbosity Integration Tests" begin
+    @testset "OpenBLAS solver with verbosity logging" begin
+        # Test basic OpenBLAS solver functionality with verbosity
+        try
+            # Test successful solve with success logging enabled
+            A_good = [2.0 1.0; 1.0 2.0]
+            b_good = [3.0, 4.0]
+            prob_good = LinearProblem(A_good, b_good)
+
+            verbose_success = LinearVerbosity(
+                blas_success = InfoLevel(),
+                blas_errors = Silent(),
+                blas_info = Silent()
+            )
+
+            @test_logs (:info, r"BLAS LU factorization.*completed successfully") solve(
+                prob_good, OpenBLASLUFactorization(); verbose = verbose_success)
+
+            # Test singular matrix with error logging
+            A_singular = [1.0 2.0; 2.0 4.0]
+            b_singular = [1.0, 2.0]
+            prob_singular = LinearProblem(A_singular, b_singular)
+
+            verbose_errors = LinearVerbosity(
+                blas_errors = WarnLevel(),
+                blas_success = Silent(),
+                blas_info = Silent()
+            )
+
+            @test_logs (:warn, r"BLAS/LAPACK.*Matrix is singular") solve(
+                prob_singular, OpenBLASLUFactorization(); verbose = verbose_errors)
+
+            # Test with info logging enabled
+            verbose_info = LinearVerbosity(
+                blas_info = InfoLevel(),
+                blas_errors = InfoLevel(),
+                blas_success = Silent()
+            )
+
+            @test_logs (:info, r"BLAS/LAPACK.*Matrix is singular") solve(
+                prob_singular, OpenBLASLUFactorization(); verbose = verbose_info)
+
+            # Test with all BLAS logging disabled - should produce no logs
+            verbose_silent = LinearVerbosity(
+                blas_errors = Silent(),
+                blas_invalid_args = Silent(),
+                blas_info = Silent(),
+                blas_success = Silent()
+            )
+
+            @test_logs min_level=SciMLLogging.Logging.Warn solve(
+                prob_singular, OpenBLASLUFactorization(); verbose = verbose_silent)
+
+            # Test condition number logging if enabled
+            verbose_with_cond = LinearVerbosity(
+                condition_number = InfoLevel(),
+                blas_success = InfoLevel(),
+                blas_errors = Silent()
+            )
+
+            @test_logs (:info, r"Matrix condition number:.*for.*matrix") match_mode=:any solve(
+                prob_good, OpenBLASLUFactorization(); verbose = verbose_with_cond)
+        catch e
+            if isa(e, ErrorException) && occursin("OpenBLAS binary is missing", string(e))
+                @info "Skipping OpenBLAS tests - OpenBLAS not available"
+            else
+                rethrow(e)
+            end
+        end
+    end
+end
+
+@testset "AppleAccelerate Verbosity Integration Tests" begin
+    @testset "AppleAccelerate solver with verbosity logging" begin
+        # Test basic AppleAccelerate solver functionality with verbosity
+        try
+            # Test successful solve with success logging enabled
+            A_good = [2.0 1.0; 1.0 2.0]
+            b_good = [3.0, 4.0]
+            prob_good = LinearProblem(A_good, b_good)
+
+            verbose_success = LinearVerbosity(
+                blas_success = InfoLevel(),
+                blas_errors = Silent(),
+                blas_info = Silent()
+            )
+
+            @test_logs (:info, r"BLAS LU factorization.*completed successfully") solve(
+                prob_good, AppleAccelerateLUFactorization(); verbose = verbose_success)
+
+            # Test singular matrix with error logging
+            A_singular = [1.0 2.0; 2.0 4.0]
+            b_singular = [1.0, 2.0]
+            prob_singular = LinearProblem(A_singular, b_singular)
+
+            verbose_errors = LinearVerbosity(
+                blas_errors = WarnLevel(),
+                blas_success = Silent(),
+                blas_info = Silent()
+            )
+
+            @test_logs (:warn, r"BLAS/LAPACK.*Matrix is singular") solve(
+                prob_singular, AppleAccelerateLUFactorization(); verbose = verbose_errors)
+
+            # Test with info logging enabled
+            verbose_info = LinearVerbosity(
+                blas_info = InfoLevel(),
+                blas_errors = InfoLevel(),
+                blas_success = Silent()
+            )
+
+            @test_logs (:info, r"BLAS/LAPACK.*Matrix is singular") solve(
+                prob_singular, AppleAccelerateLUFactorization(); verbose = verbose_info)
+
+            # Test with all BLAS logging disabled - should produce no logs
+            verbose_silent = LinearVerbosity(
+                blas_errors = Silent(),
+                blas_invalid_args = Silent(),
+                blas_info = Silent(),
+                blas_success = Silent()
+            )
+
+            @test_logs min_level=SciMLLogging.Logging.Warn solve(
+                prob_singular, AppleAccelerateLUFactorization(); verbose = verbose_silent)
+
+            # Test condition number logging if enabled
+            verbose_with_cond = LinearVerbosity(
+                condition_number = InfoLevel(),
+                blas_success = InfoLevel(),
+                blas_errors = Silent()
+            )
+
+            @test_logs (:info, r"Matrix condition number:.*for.*matrix") match_mode=:any solve(
+                prob_good, AppleAccelerateLUFactorization(); verbose = verbose_with_cond)
+        catch e
+            if isa(e, ErrorException) && occursin("AppleAccelerate binary is missing", string(e))
+                @info "Skipping AppleAccelerate tests - AppleAccelerate not available"
+            else
+                rethrow(e)
+            end
+        end
+    end
+end
+
+@testset "MKL Verbosity Integration Tests" begin
+    @testset "MKL solver with verbosity logging" begin
+        # Test basic MKL solver functionality with verbosity
+        try
+            # Test successful solve with success logging enabled
+            A_good = [2.0 1.0; 1.0 2.0]
+            b_good = [3.0, 4.0]
+            prob_good = LinearProblem(A_good, b_good)
+
+            verbose_success = LinearVerbosity(
+                blas_success = InfoLevel(),
+                blas_errors = Silent(),
+                blas_info = Silent()
+            )
+
+            @test_logs (:info, r"BLAS LU factorization.*completed successfully") solve(
+                prob_good, MKLLUFactorization(); verbose = verbose_success)
+
+            # Test singular matrix with error logging
+            A_singular = [1.0 2.0; 2.0 4.0]
+            b_singular = [1.0, 2.0]
+            prob_singular = LinearProblem(A_singular, b_singular)
+
+            verbose_errors = LinearVerbosity(
+                blas_errors = WarnLevel(),
+                blas_success = Silent(),
+                blas_info = Silent()
+            )
+
+            @test_logs (:warn, r"BLAS/LAPACK.*Matrix is singular") solve(
+                prob_singular, MKLLUFactorization(); verbose = verbose_errors)
+
+            # Test with info logging enabled
+            verbose_info = LinearVerbosity(
+                blas_info = InfoLevel(),
+                blas_errors = InfoLevel(),
+                blas_success = Silent()
+            )
+
+            @test_logs (:info, r"BLAS/LAPACK.*Matrix is singular") solve(
+                prob_singular, MKLLUFactorization(); verbose = verbose_info)
+
+            # Test with all BLAS logging disabled - should produce no logs
+            verbose_silent = LinearVerbosity(
+                blas_errors = Silent(),
+                blas_invalid_args = Silent(),
+                blas_info = Silent(),
+                blas_success = Silent()
+            )
+
+            @test_logs min_level=SciMLLogging.Logging.Warn solve(
+                prob_singular, MKLLUFactorization(); verbose = verbose_silent)
+
+            # Test condition number logging if enabled
+            verbose_with_cond = LinearVerbosity(
+                condition_number = InfoLevel(),
+                blas_success = InfoLevel(),
+                blas_errors = Silent()
+            )
+
+            @test_logs (:info, r"Matrix condition number:.*for.*matrix") match_mode=:any solve(
+                prob_good, MKLLUFactorization(); verbose = verbose_with_cond)
+        catch e
+            if isa(e, ErrorException) && occursin("MKL binary is missing", string(e))
+                @info "Skipping MKL tests - MKL not available"
+            else
+                rethrow(e)
+            end
+        end
+    end
 end