Apply JuliaFormatter to modified files

Author: ChrisRackauckas

format_autotune.jl

@@ -0,0 +1,10 @@
+using Pkg
+Pkg.add("JuliaFormatter")
+using JuliaFormatter
+
+# Format only the changed files with SciMLStyle
+format("lib/LinearSolveAutotune/src/gpu_detection.jl", SciMLStyle())
+format("lib/LinearSolveAutotune/src/telemetry.jl", SciMLStyle())
+format("lib/LinearSolveAutotune/src/benchmarking.jl", SciMLStyle())
+
+println("Formatting complete!")

lib/LinearSolveAutotune/src/benchmarking.jl

@@ -13,37 +13,38 @@ Uses more strict rules for BLAS-dependent algorithms with non-standard types.
 function test_algorithm_compatibility(alg, eltype::Type, test_size::Int = 4)
     # Get algorithm name for type-specific compatibility rules
     alg_name = string(typeof(alg).name.name)
-    
+
     # Define strict compatibility rules for BLAS-dependent algorithms
-    if !(eltype <: LinearAlgebra.BLAS.BlasFloat) && alg_name in ["BLISFactorization", "MKLLUFactorization", "AppleAccelerateLUFactorization"]
+    if !(eltype <: LinearAlgebra.BLAS.BlasFloat) && alg_name in [
+        "BLISFactorization", "MKLLUFactorization", "AppleAccelerateLUFactorization"]
         return false  # BLAS algorithms not compatible with non-standard types
     end
 
     if alg_name == "BLISLUFactorization" && Sys.isapple()
         return false  # BLISLUFactorization has no Apple Silicon binary
     end
-    
+
     # For standard types or algorithms that passed the strict check, test functionality
     try
         # Create a small test problem with the specified element type
         rng = MersenneTwister(123)
         A = rand(rng, eltype, test_size, test_size)
         b = rand(rng, eltype, test_size)
         u0 = rand(rng, eltype, test_size)
-        
+
         prob = LinearProblem(A, b; u0 = u0)
-        
+
         # Try to solve - if it works, the algorithm is compatible
         sol = solve(prob, alg)
-        
+
         # Additional check: verify the solution is actually of the expected type
         if !isa(sol.u, AbstractVector{eltype})
             @debug "Algorithm $alg_name returned wrong element type for $eltype"
             return false
         end
-        
+
         return true
-        
+
     catch e
         # Algorithm failed - not compatible with this element type
         @debug "Algorithm $alg_name failed for $eltype: $e"
@@ -60,14 +61,14 @@ Returns filtered algorithms and names.
 function filter_compatible_algorithms(algorithms, alg_names, eltype::Type)
     compatible_algs = []
     compatible_names = String[]
-    
+
     for (alg, name) in zip(algorithms, alg_names)
         if test_algorithm_compatibility(alg, eltype)
             push!(compatible_algs, alg)
             push!(compatible_names, name)
         end
     end
-    
+
     return compatible_algs, compatible_names
 end
 
@@ -89,36 +90,37 @@ function benchmark_algorithms(matrix_sizes, algorithms, alg_names, eltypes;
 
     # Initialize results DataFrame
     results_data = []
-    
+
     # Calculate total number of benchmarks for progress bar
     total_benchmarks = 0
     for eltype in eltypes
         # Pre-filter to estimate the actual number
         test_algs, _ = filter_compatible_algorithms(algorithms, alg_names, eltype)
         total_benchmarks += length(matrix_sizes) * length(test_algs)
     end
-    
+
     # Create progress bar
-    progress = Progress(total_benchmarks, desc="Benchmarking: ", 
-                       barlen=50, showspeed=true)
+    progress = Progress(total_benchmarks, desc = "Benchmarking: ",
+        barlen = 50, showspeed = true)
 
     try
         for eltype in eltypes
             # Filter algorithms for this element type
-            compatible_algs, compatible_names = filter_compatible_algorithms(algorithms, alg_names, eltype)
-            
+            compatible_algs,
+            compatible_names = filter_compatible_algorithms(algorithms, alg_names, eltype)
+
             if isempty(compatible_algs)
                 @warn "No algorithms compatible with $eltype, skipping..."
                 continue
             end
-            
+
             for n in matrix_sizes
                 # Create test problem with specified element type
                 rng = MersenneTwister(123)  # Consistent seed for reproducibility
                 A = rand(rng, eltype, n, n)
                 b = rand(rng, eltype, n)
                 u0 = rand(rng, eltype, n)
-                
+
                 # Compute reference solution with LUFactorization if correctness check is enabled
                 reference_solution = nothing
                 if check_correctness
@@ -133,9 +135,9 @@ function benchmark_algorithms(matrix_sizes, algorithms, alg_names, eltypes;
 
                 for (alg, name) in zip(compatible_algs, compatible_names)
                     # Update progress description
-                    ProgressMeter.update!(progress, 
-                        desc="Benchmarking $name on $(n)×$(n) $eltype matrix: ")
-                    
+                    ProgressMeter.update!(progress,
+                        desc = "Benchmarking $name on $(n)×$(n) $eltype matrix: ")
+
                     gflops = 0.0
                     success = true
                     error_msg = ""
@@ -149,12 +151,13 @@ function benchmark_algorithms(matrix_sizes, algorithms, alg_names, eltypes;
 
                         # Warmup run and correctness check
                         warmup_sol = solve(prob, alg)
-                        
+
                         # Check correctness if reference solution is available
                         if check_correctness && reference_solution !== nothing
                             # Compute relative error
-                            rel_error = norm(warmup_sol.u - reference_solution.u) / norm(reference_solution.u)
-                            
+                            rel_error = norm(warmup_sol.u - reference_solution.u) /
+                                        norm(reference_solution.u)
+
                             if rel_error > correctness_tol
                                 passed_correctness = false
                                 @warn "Algorithm $name failed correctness check for size $n, eltype $eltype. " *
@@ -164,7 +167,7 @@ function benchmark_algorithms(matrix_sizes, algorithms, alg_names, eltypes;
                                 error_msg = "Failed correctness check (rel_error = $(round(rel_error, sigdigits=3)))"
                             end
                         end
-                        
+
                         # Only benchmark if correctness check passed
                         if passed_correctness
                             # Actual benchmark
@@ -195,7 +198,7 @@ function benchmark_algorithms(matrix_sizes, algorithms, alg_names, eltypes;
                             success = success,
                             error = error_msg
                         ))
-                    
+
                     # Update progress
                     ProgressMeter.next!(progress)
                 end
@@ -216,15 +219,16 @@ end
 Get the matrix sizes to benchmark based on the requested size categories.
 
 Size categories:
-- `:tiny` - 5:5:20 (for very small problems)
-- `:small` - 20:20:100 (for small problems)
-- `:medium` - 100:50:300 (for typical problems)
-- `:large` - 300:100:1000 (for larger problems)
-- `:big` - vcat(1000:2000:10000, 10000:5000:20000) (for very large/GPU problems)
+
+  - `:tiny` - 5:5:20 (for very small problems)
+  - `:small` - 20:20:100 (for small problems)
+  - `:medium` - 100:50:300 (for typical problems)
+  - `:large` - 300:100:1000 (for larger problems)
+  - `:big` - vcat(1000:2000:10000, 10000:5000:20000) (for very large/GPU problems)
 """
 function get_benchmark_sizes(size_categories::Vector{Symbol})
     sizes = Int[]
-    
+
     for category in size_categories
         if category == :tiny
             append!(sizes, 5:5:20)
@@ -240,7 +244,7 @@ function get_benchmark_sizes(size_categories::Vector{Symbol})
             @warn "Unknown size category: $category. Skipping."
         end
     end
-    
+
     # Remove duplicates and sort
     return sort(unique(sizes))
 end
@@ -277,10 +281,10 @@ function categorize_results(df::DataFrame)
 
     for eltype in eltypes
         @info "Categorizing results for element type: $eltype"
-        
+
         # Filter results for this element type
         eltype_df = filter(row -> row.eltype == eltype, successful_df)
-        
+
         if nrow(eltype_df) == 0
             continue
         end
@@ -295,24 +299,27 @@ function categorize_results(df::DataFrame)
 
             # Calculate average GFLOPs for each algorithm in this range
             avg_results = combine(groupby(range_df, :algorithm), :gflops => mean => :avg_gflops)
-            
+
             # Sort by performance
-            sort!(avg_results, :avg_gflops, rev=true)
+            sort!(avg_results, :avg_gflops, rev = true)
 
             # Find the best algorithm (for complex types, avoid RFLU if possible)
             if nrow(avg_results) > 0
                 best_alg = avg_results.algorithm[1]
-                
+
                 # For complex types, check if best is RFLU and we have alternatives
-                if (eltype == "ComplexF32" || eltype == "ComplexF64") && 
-                   (contains(best_alg, "RFLU") || contains(best_alg, "RecursiveFactorization"))
-                    
+                if (eltype == "ComplexF32" || eltype == "ComplexF64") &&
+                   (contains(best_alg, "RFLU") ||
+                    contains(best_alg, "RecursiveFactorization"))
+
                     # Look for the best non-RFLU algorithm
                     for i in 2:nrow(avg_results)
                         alt_alg = avg_results.algorithm[i]
-                        if !contains(alt_alg, "RFLU") && !contains(alt_alg, "RecursiveFactorization")
+                        if !contains(alt_alg, "RFLU") &&
+                           !contains(alt_alg, "RecursiveFactorization")
                             # Check if performance difference is not too large (within 20%)
-                            perf_ratio = avg_results.avg_gflops[i] / avg_results.avg_gflops[1]
+                            perf_ratio = avg_results.avg_gflops[i] /
+                                         avg_results.avg_gflops[1]
                             if perf_ratio > 0.8
                                 @info "Using $alt_alg instead of $best_alg for $eltype at $range_name ($(round(100*perf_ratio, digits=1))% of RFLU performance) to avoid complex number issues"
                                 best_alg = alt_alg
@@ -323,7 +330,7 @@ function categorize_results(df::DataFrame)
                         end
                     end
                 end
-                
+
                 category_key = "$(eltype)_$(range_name)"
                 categories[category_key] = best_alg
                 best_idx = findfirst(==(best_alg), avg_results.algorithm)