Implement assertive algorithm detection with skip_missing_algs flag

- Add skip_missing_algs parameter (default false) to autotune_setup
- By default, error when expected algorithms are missing from compatible systems
- RFLUFactorization errors if missing (hard dependency)
- GPU algorithms error if hardware detected but packages not loaded
- Platform-specific warnings for Apple Accelerate on macOS
- Pass skip_missing_algs=true to get warnings instead of errors
- Update documentation with missing algorithm handling section
- More assertive approach ensures users get all compatible algorithms

This makes autotune more assertive about finding all available algorithms
instead of silently skipping them, improving benchmark comprehensiveness.

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

Co-Authored-By: Claude <[email protected]>

Author: ChrisRackauckas

docs/src/tutorials/autotune.md

@@ -94,6 +94,24 @@ results = autotune_setup(set_preferences = false)
 results = autotune_setup(make_plot = false)
 ```
 
+### Missing Algorithm Handling
+
+By default, autotune is assertive about finding all expected algorithms:
+
+```julia
+# Default behavior: error if expected algorithms are missing
+results = autotune_setup()  # Will error if RFLUFactorization missing
+
+# Allow missing algorithms (useful for incomplete setups)
+results = autotune_setup(skip_missing_algs = true)  # Will warn instead of error
+```
+
+**When algorithms might be missing:**
+- RFLUFactorization should always be available (hard dependency)
+- GPU algorithms require CUDA.jl or Metal.jl to be loaded
+- Apple Accelerate should work on macOS systems
+- MKL algorithms require MKL.jl package
+
 ## Understanding Algorithm Compatibility
 
 The autotuner automatically detects which algorithms work with which element types:

lib/LinearSolveAutotune/src/LinearSolveAutotune.jl

@@ -33,7 +33,8 @@ include("preferences.jl")
         set_preferences::Bool = true,
         samples::Int = 5,
         seconds::Float64 = 0.5,
-        eltypes = (Float32, Float64, ComplexF32, ComplexF64))
+        eltypes = (Float32, Float64, ComplexF32, ComplexF64),
+        skip_missing_algs::Bool = false)
 
 Run a comprehensive benchmark of all available LU factorization methods and optionally:
 
@@ -52,6 +53,7 @@ Run a comprehensive benchmark of all available LU factorization methods and opti
   - `samples::Int = 5`: Number of benchmark samples per algorithm/size
   - `seconds::Float64 = 0.5`: Maximum time per benchmark
   - `eltypes = (Float32, Float64, ComplexF32, ComplexF64)`: Element types to benchmark
+  - `skip_missing_algs::Bool = false`: If false, error when expected algorithms are missing; if true, warn instead
 
 # Returns
 
@@ -75,6 +77,9 @@ results = autotune_setup(eltypes = (Float64, ComplexF64))
 
 # Test with BigFloat (note: most BLAS algorithms will be excluded)
 results = autotune_setup(eltypes = (BigFloat,), telemetry = false)
+
+# Allow missing algorithms (useful for incomplete setups)
+results = autotune_setup(skip_missing_algs = true)
 ```
 """
 function autotune_setup(;
@@ -84,7 +89,8 @@ function autotune_setup(;
         set_preferences::Bool = true,
         samples::Int = 5,
         seconds::Float64 = 0.5,
-        eltypes = (Float32, Float64, ComplexF32, ComplexF64))
+        eltypes = (Float32, Float64, ComplexF32, ComplexF64),
+        skip_missing_algs::Bool = false)
     @info "Starting LinearSolve.jl autotune setup..."
     @info "Configuration: large_matrices=$large_matrices, telemetry=$telemetry, make_plot=$make_plot, set_preferences=$set_preferences"
     @info "Element types to benchmark: $(join(eltypes, ", "))"
@@ -104,11 +110,11 @@ function autotune_setup(;
     @info "System detected: $(system_info["os"]) $(system_info["arch"]) with $(system_info["num_cores"]) cores"
 
     # Get available algorithms
-    cpu_algs, cpu_names = get_available_algorithms()
+    cpu_algs, cpu_names = get_available_algorithms(; skip_missing_algs = skip_missing_algs)
     @info "Found $(length(cpu_algs)) CPU algorithms: $(join(cpu_names, ", "))"
 
     # Add GPU algorithms if available
-    gpu_algs, gpu_names = get_gpu_algorithms()
+    gpu_algs, gpu_names = get_gpu_algorithms(; skip_missing_algs = skip_missing_algs)
     if !isempty(gpu_algs)
         @info "Found $(length(gpu_algs)) GPU algorithms: $(join(gpu_names, ", "))"
     end

lib/LinearSolveAutotune/src/algorithms.jl

@@ -1,11 +1,12 @@
 # Algorithm detection and creation functions
 
 """
-    get_available_algorithms()
+    get_available_algorithms(; skip_missing_algs::Bool = false)
 
 Returns a list of available LU factorization algorithms based on the system and loaded packages.
+If skip_missing_algs=false, errors when expected algorithms are missing; if true, warns instead.
 """
-function get_available_algorithms()
+function get_available_algorithms(; skip_missing_algs::Bool = false)
     algs = []
     alg_names = String[]
 
@@ -22,20 +23,38 @@ function get_available_algorithms()
         push!(alg_names, "MKLLUFactorization")
     end
 
-    # Apple Accelerate if available  
+    # Apple Accelerate if available (should be available on macOS)
     if LinearSolve.appleaccelerate_isavailable()
         push!(algs, AppleAccelerateLUFactorization())
         push!(alg_names, "AppleAccelerateLUFactorization")
+    else
+        # Check if we're on macOS and Apple Accelerate should be available
+        if Sys.isapple() && !skip_missing_algs
+            msg = "macOS system detected but Apple Accelerate not available. This is unexpected."
+            @warn msg
+        end
     end
 
-    # RecursiveFactorization if loaded
+    # RecursiveFactorization - should always be available as it's a hard dependency
     try
         if LinearSolve.userecursivefactorization(nothing)
             push!(algs, RFLUFactorization())
             push!(alg_names, "RFLUFactorization")
+        else
+            msg = "RFLUFactorization should be available (RecursiveFactorization.jl is a hard dependency)"
+            if skip_missing_algs
+                @warn msg
+            else
+                error(msg * ". Pass `skip_missing_algs=true` to continue with warning instead.")
+            end
+        end
+    catch e
+        msg = "RFLUFactorization failed to load: $e"
+        if skip_missing_algs
+            @warn msg
+        else
+            error(msg * ". Pass `skip_missing_algs=true` to continue with warning instead.")
         end
-    catch
-        # RFLUFactorization not available
     end
 
     # SimpleLU always available
@@ -46,11 +65,12 @@ function get_available_algorithms()
 end
 
 """
-    get_gpu_algorithms()
+    get_gpu_algorithms(; skip_missing_algs::Bool = false)
 
 Returns GPU-specific algorithms if GPU hardware and packages are available.
+If skip_missing_algs=false, errors when GPU hardware is detected but algorithms are missing; if true, warns instead.
 """
-function get_gpu_algorithms()
+function get_gpu_algorithms(; skip_missing_algs::Bool = false)
     gpu_algs = []
     gpu_names = String[]
 
@@ -59,8 +79,13 @@ function get_gpu_algorithms()
         try
             push!(gpu_algs, CudaOffloadFactorization())
             push!(gpu_names, "CudaOffloadFactorization")
-        catch
-            # CUDA extension not loaded
+        catch e
+            msg = "CUDA hardware detected but CudaOffloadFactorization not available: $e. Load CUDA.jl package."
+            if skip_missing_algs
+                @warn msg
+            else
+                error(msg * " Pass `skip_missing_algs=true` to continue with warning instead.")
+            end
         end
     end
 
@@ -69,8 +94,13 @@ function get_gpu_algorithms()
         try
             push!(gpu_algs, MetalLUFactorization())
             push!(gpu_names, "MetalLUFactorization")
-        catch
-            # Metal extension not loaded
+        catch e
+            msg = "Metal hardware detected but MetalLUFactorization not available: $e. Load Metal.jl package."
+            if skip_missing_algs
+                @warn msg
+            else
+                error(msg * " Pass `skip_missing_algs=true` to continue with warning instead.")
+            end
         end
     end