Make BLAS logging type-stable by replacing Dict with struct

Replace Dict{Symbol, Any} with BlasOperationInfo struct to eliminate
runtime dispatch in BLAS error logging code. Uses sentinel values
(-Inf for condition_number, () for rhs_size, Nothing for rhs_type)
instead of Union types for better type stability.

Changes:
- src/blas_logging.jl: Created BlasOperationInfo struct with concrete
  field types and sentinel values
- src/mkl.jl, src/openblas.jl, src/appleaccelerate.jl: Updated to use
  struct field access instead of Dict indexing
- test/verbosity.jl: Updated tests to use struct interface
- test/nopre/jet.jl: Re-enabled MKLLUFactorization JET test now that
  type stability is fixed

This fixes JET test failures on Windows v1.12 and other platforms
caused by runtime dispatch in _format_context_pair.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ChrisRackauckas

src/appleaccelerate.jl

@@ -263,17 +263,20 @@ function SciMLBase.solve!(cache::LinearCache, alg::AppleAccelerateLUFactorizatio
         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))
+            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
+                    if isinf(op_info.condition_number)
                         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"
+                        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(
+                verb_option,
+                message = blas_info_msg(
                     :dgetrf, info_value; extra_context = op_info)
                 @SciMLMessage(message, verbose, verb_option)
             end
@@ -282,13 +285,13 @@ function SciMLBase.solve!(cache::LinearCache, alg::AppleAccelerateLUFactorizatio
                 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
+                    if isinf(op_info.condition_number)
                         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"
+                        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"
+                return "BLAS LU factorization (dgetrf) completed successfully for $(op_info.matrix_size) matrix"
             end
         end
 
@@ -326,7 +329,8 @@ const PREALLOCATED_APPLE32_LU = begin
     LU(luinst.factors, similar(A, Cint, 0), luinst.info), Ref{Cint}()
 end
 
-function LinearSolve.init_cacheval(alg::AppleAccelerate32MixedLUFactorization, A, b, u, Pl, Pr,
+function LinearSolve.init_cacheval(
+        alg::AppleAccelerate32MixedLUFactorization, A, b, u, Pl, Pr,
         maxiters::Int, abstol, reltol, verbose::Union{LinearVerbosity, Bool},
         assumptions::OperatorAssumptions)
     # Pre-allocate appropriate 32-bit arrays based on input type
@@ -349,7 +353,8 @@ function SciMLBase.solve!(cache::LinearCache, alg::AppleAccelerate32MixedLUFacto
 
     if cache.isfresh
         # Get pre-allocated arrays from cacheval
-        luinst, info, A_32, b_32, u_32 = @get_cacheval(cache, :AppleAccelerate32MixedLUFactorization)
+        luinst, info, A_32,
+        b_32, u_32 = @get_cacheval(cache, :AppleAccelerate32MixedLUFactorization)
         # Compute 32-bit type on demand and copy A
         T32 = eltype(A) <: Complex ? ComplexF32 : Float32
         A_32 .= T32.(A)
@@ -365,14 +370,15 @@ function SciMLBase.solve!(cache::LinearCache, alg::AppleAccelerate32MixedLUFacto
         cache.isfresh = false
     end
 
-    A_lu, info, A_32, b_32, u_32 = @get_cacheval(cache, :AppleAccelerate32MixedLUFactorization)
+    A_lu, info, A_32, b_32,
+    u_32 = @get_cacheval(cache, :AppleAccelerate32MixedLUFactorization)
     require_one_based_indexing(cache.u, cache.b)
     m, n = size(A_lu, 1), size(A_lu, 2)
 
     # Compute types on demand for conversions
     T32 = eltype(A) <: Complex ? ComplexF32 : Float32
     Torig = eltype(cache.u)
-    
+
     # Copy b to pre-allocated 32-bit array
     b_32 .= T32.(cache.b)
 

src/blas_logging.jl

@@ -1,3 +1,21 @@
+"""
+Type-stable container for BLAS operation information.
+
+Uses sentinel values for optional fields to maintain type stability:
+
+  - condition_number: -Inf means not computed
+  - rhs_size: () means not applicable
+  - rhs_type: Nothing means not applicable
+"""
+struct BlasOperationInfo
+    matrix_size::Tuple{Int, Int}
+    matrix_type::Type
+    element_type::Type
+    condition_number::Float64  # -Inf means not computed
+    rhs_size::Tuple{Vararg{Int}}  # () means not applicable
+    rhs_type::Type  # Nothing means not applicable
+    memory_usage_MB::Float64
+end
 
 """
     interpret_blas_code(func::Symbol, info::Integer)
@@ -84,23 +102,50 @@ function interpret_positive_info(func::Symbol, info::Integer)
     end
 end
 
+"""
+Format BlasOperationInfo fields into human-readable strings.
+
+Type-stable implementation using concrete struct fields instead of Dict iteration.
+"""
+function _format_blas_context(op_info::BlasOperationInfo)
+    parts = String[]
+
+    # Always-present fields
+    push!(parts, "Matrix size: $(op_info.matrix_size)")
+    push!(parts, "Matrix type: $(op_info.matrix_type)")
+    push!(parts, "Element type: $(op_info.element_type)")
+    push!(parts, "Memory usage: $(op_info.memory_usage_MB) MB")
+
+    # Optional fields - check for sentinel values
+    if !isinf(op_info.condition_number)
+        push!(parts, "Condition number: $(round(op_info.condition_number, sigdigits=4))")
+    end
+
+    if !isempty(op_info.rhs_size)
+        push!(parts, "RHS size: $(op_info.rhs_size)")
+    end
 
+    if op_info.rhs_type !== Nothing
+        push!(parts, "RHS type: $(op_info.rhs_type)")
+    end
 
-# Type barrier for string interpolation with Any-typed values
-# The ::String return type annotation prevents JET from seeing runtime dispatch propagate
-@noinline _format_context_pair(key::Symbol, value)::String = string(key, ": ", value)
+    return parts
+end
 
 """
-    blas_info_msg(func::Symbol, info::Integer, verbose::LinearVerbosity;
-                  extra_context::Dict{Symbol,Any} = Dict())
+    blas_info_msg(func::Symbol, info::Integer;
+                  extra_context::BlasOperationInfo = BlasOperationInfo(
+                      (0, 0), Nothing, Nothing, -Inf, (), Nothing, 0.0))
 
 Log BLAS/LAPACK return code information with appropriate verbosity level.
 """
 function blas_info_msg(func::Symbol, info::Integer;
-        extra_context::Dict{Symbol, Any} = Dict())
+        extra_context::BlasOperationInfo = BlasOperationInfo(
+            (0, 0), Nothing, Nothing, -Inf, (), Nothing, 0.0))
     category, message, details = interpret_blas_code(func, info)
 
-    verbosity_field = if category in [:singular_matrix, :not_positive_definite, :convergence_failure]
+    verbosity_field = if category in [
+        :singular_matrix, :not_positive_definite, :convergence_failure]
         :blas_errors
     elseif category == :invalid_argument
         :blas_invalid_args
@@ -114,17 +159,18 @@ function blas_info_msg(func::Symbol, info::Integer;
     msg_info = info
 
     # Build complete message with all details
-    full_msg = if !isempty(extra_context) || msg_details !== nothing
+    # Check if extra_context has any non-sentinel values
+    has_extra_context = extra_context.matrix_size != (0, 0)
+
+    full_msg = if has_extra_context || msg_details !== nothing
         parts = String[msg_main]
         if msg_details !== nothing
             push!(parts, "Details: $msg_details")
         end
         push!(parts, "Return code (info): $msg_info")
-        if !isempty(extra_context)
-            for (key, value) in extra_context
-                # Use type barrier to prevent runtime dispatch from propagating
-                push!(parts, _format_context_pair(key, value))
-            end
+        if has_extra_context
+            # Type-stable formatting using struct fields
+            append!(parts, _format_blas_context(extra_context))
         end
         join(parts, "\n  ")
     else
@@ -134,39 +180,38 @@ function blas_info_msg(func::Symbol, info::Integer;
     verbosity_field, full_msg
 end
 
-
 function get_blas_operation_info(func::Symbol, A, b; condition = false)
-    info = Dict{Symbol, Any}()
+    # Matrix properties (always present)
+    matrix_size = size(A)
+    matrix_type = typeof(A)
+    element_type = eltype(A)
 
-    # Matrix properties
-    info[:matrix_size] = size(A)
-    info[:matrix_type] = typeof(A)
-    info[:element_type] = eltype(A)
+    # Memory usage estimate (always present)
+    mem_bytes = prod(matrix_size) * sizeof(element_type)
+    memory_usage_MB = round(mem_bytes / 1024^2, digits = 2)
 
-    # Condition number (based on verbosity setting)
-    if condition && size(A, 1) == size(A, 2)
+    # Condition number (optional - use -Inf as sentinel)
+    condition_number = if condition && matrix_size[1] == matrix_size[2]
         try
-            cond_num = cond(A)
-            info[:condition_number] = cond_num
-
-            # Log the condition number if enabled  
-            cond_msg = "Matrix condition number: $(round(cond_num, sigdigits=4)) for $(size(A, 1))×$(size(A, 2)) matrix in $func"
-
+            cond(A)
         catch
-            # Skip if condition number computation fails
-            info[:condition_number] = nothing
+            -Inf
         end
+    else
+        -Inf
     end
 
-    # RHS properties if provided
-    if b !== nothing
-        info[:rhs_size] = size(b)
-        info[:rhs_type] = typeof(b)
-    end
-
-    # Memory usage estimate
-    mem_bytes = prod(size(A)) * sizeof(eltype(A))
-    info[:memory_usage_MB] = round(mem_bytes / 1024^2, digits = 2)
-
-    return info
-end
+    # RHS properties (optional - use () and Nothing as sentinels)
+    rhs_size = b !== nothing ? size(b) : ()
+    rhs_type = b !== nothing ? typeof(b) : Nothing
+
+    return BlasOperationInfo(
+        matrix_size,
+        matrix_type,
+        element_type,
+        condition_number,
+        rhs_size,
+        rhs_type,
+        memory_usage_MB
+    )
+end

src/mkl.jl

@@ -12,7 +12,8 @@ struct MKLLUFactorization <: AbstractFactorization end
 # MKL_jll < 2022.2 doesn't support the mixed LP64 and ILP64 interfaces that we make use of in LinearSolve
 # In particular, the `_64` APIs do not exist
 # https://www.intel.com/content/www/us/en/developer/articles/release-notes/onemkl-release-notes-2022.html
-@static if !@isdefined(MKL_jll) || !MKL_jll.is_available() || pkgversion(MKL_jll) < v"2022.2"
+@static if !@isdefined(MKL_jll) || !MKL_jll.is_available() ||
+           pkgversion(MKL_jll) < v"2022.2"
     __mkl_isavailable() = false
 else
     __mkl_isavailable() = true
@@ -252,32 +253,40 @@ function SciMLBase.solve!(cache::LinearCache, alg::MKLLUFactorization;
         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))
+            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))
                 if cache.verbose.condition_number != Silent()
-                    if op_info[:condition_number] === nothing
-                        @SciMLMessage("Matrix condition number calculation failed.", cache.verbose, :condition_number)
+                    if isinf(op_info.condition_number)
+                        @SciMLMessage("Matrix condition number calculation failed.",
+                            cache.verbose, :condition_number)
                     else
-                        @SciMLMessage("Matrix condition number: $(round(op_info[:condition_number], sigdigits=4)) for $(size(A, 1))×$(size(A, 2)) matrix in dgetrf", cache.verbose, :condition_number)
+                        @SciMLMessage("Matrix condition number: $(round(op_info.condition_number, sigdigits=4)) for $(size(A, 1))×$(size(A, 2)) matrix in dgetrf",
+                            cache.verbose, :condition_number)
                     end
                 end
-                verb_option, message = blas_info_msg(
+                verb_option,
+                message = blas_info_msg(
                     :dgetrf, info_value; extra_context = op_info)
                 @SciMLMessage(message, verbose, verb_option)
             end
         else
             if cache.verbose.blas_success != Silent()
-                op_info = get_blas_operation_info(:dgetrf, A, cache.b, condition = !isa(verbose.condition_number, SciMLLogging.Silent))
+                op_info = get_blas_operation_info(:dgetrf, A, cache.b,
+                    condition = !isa(verbose.condition_number, SciMLLogging.Silent))
                 if cache.verbose.condition_number != Silent()
-                    if op_info[:condition_number] === nothing
-                        @SciMLMessage("Matrix condition number calculation failed.", cache.verbose, :condition_number)
+                    if isinf(op_info.condition_number)
+                        @SciMLMessage("Matrix condition number calculation failed.",
+                            cache.verbose, :condition_number)
                     else
-                        @SciMLMessage("Matrix condition number: $(round(op_info[:condition_number], sigdigits=4)) for $(size(A, 1))×$(size(A, 2)) matrix in dgetrf",
+                        @SciMLMessage("Matrix condition number: $(round(op_info.condition_number, sigdigits=4)) for $(size(A, 1))×$(size(A, 2)) matrix in dgetrf",
                             cache.verbose, :condition_number)
                     end
                 end
-                @SciMLMessage("BLAS LU factorization (dgetrf) completed successfully for $(op_info[:matrix_size]) matrix", cache.verbose, :blas_success)
+                @SciMLMessage("BLAS LU factorization (dgetrf) completed successfully for $(op_info.matrix_size) matrix",
+                    cache.verbose, :blas_success)
             end
         end
 
@@ -360,7 +369,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::MKL32MixedLUFactorization;
     # Compute types on demand for conversions
     T32 = eltype(A) <: Complex ? ComplexF32 : Float32
     Torig = eltype(cache.u)
-    
+
     # Copy b to pre-allocated 32-bit array
     b_32 .= T32.(cache.b)
 

src/openblas.jl

@@ -274,17 +274,20 @@ function SciMLBase.solve!(cache::LinearCache, alg::OpenBLASLUFactorization;
         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))
+            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
+                    if isinf(op_info.condition_number)
                         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"
+                        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(
+                verb_option,
+                message = blas_info_msg(
                     :dgetrf, info_value; extra_context = op_info)
                 @SciMLMessage(message, verbose, verb_option)
             end
@@ -293,13 +296,13 @@ function SciMLBase.solve!(cache::LinearCache, alg::OpenBLASLUFactorization;
                 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
+                    if isinf(op_info.condition_number)
                         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"
+                        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"
+                return "BLAS LU factorization (dgetrf) completed successfully for $(op_info.matrix_size) matrix"
             end
         end
 
@@ -359,7 +362,8 @@ function SciMLBase.solve!(cache::LinearCache, alg::OpenBLAS32MixedLUFactorizatio
 
     if cache.isfresh
         # Get pre-allocated arrays from cacheval
-        luinst, info, A_32, b_32, u_32 = @get_cacheval(cache, :OpenBLAS32MixedLUFactorization)
+        luinst, info, A_32, b_32,
+        u_32 = @get_cacheval(cache, :OpenBLAS32MixedLUFactorization)
         # Compute 32-bit type on demand and copy A
         T32 = eltype(A) <: Complex ? ComplexF32 : Float32
         A_32 .= T32.(A)
@@ -382,7 +386,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::OpenBLAS32MixedLUFactorizatio
     # Compute types on demand for conversions
     T32 = eltype(A) <: Complex ? ComplexF32 : Float32
     Torig = eltype(cache.u)
-    
+
     # Copy b to pre-allocated 32-bit array
     b_32 .= T32.(cache.b)