Make more tests compatible with 1.11 (#552)

* Make more tests compatible with 1.11

* No fail fast

* Reorganize tests

* Fixes

* Type stability

* Fix

* Fix hvp mode

* Fixes

Author: gdalle

.github/workflows/Test.yml

@@ -25,7 +25,7 @@ jobs:
       actions: write
       contents: read
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
         version:
           - "1.10"  # TODO: 1 (as of 2024.10.08, 1 means 1.11 and we're not ready yet)
@@ -44,7 +44,6 @@ jobs:
           - Back/Mooncake
           - Back/PolyesterForwardDiff
           - Back/ReverseDiff
-          - Back/SecondOrder
           - Back/SymbolicBackends
           - Back/Tracker
           - Back/Zygote
@@ -61,12 +60,6 @@ jobs:
             group: Back/Enzyme
           - version: "1.11"
             group: Back/Mooncake
-          - version: "1.11"
-            group: Back/SecondOrder
-          - version: "1.11"
-            group: Misc/Internals
-          - version: "1.11"
-            group: Misc/SparsityDetector
     env:
       JULIA_DI_TEST_GROUP: ${{ matrix.group }}
     steps:

DifferentiationInterface/src/utils/traits.jl

@@ -134,8 +134,7 @@ function hvp_mode(ba::SecondOrder)
         return ReverseOverForward()
     elseif Bool(pullback_performance(outer(ba))) && Bool(pullback_performance(inner(ba)))
         return ReverseOverReverse()
-    elseif Bool(pushforward_performance(outer(ba))) &&
-        Bool(pushforward_performance(inner(ba)))
+    else
         return ForwardOverForward()
     end
 end

DifferentiationInterface/test/Back/ChainRulesBackends/chainrules_zygote.jl

@@ -17,7 +17,6 @@ test_differentiation(
     AutoChainRules(ZygoteRuleConfig()),
     default_scenarios();
     excluded=[:second_derivative],
-    second_order=VERSION >= v"1.10",
     logging=LOGGING,
 );
 

DifferentiationInterface/test/Back/Enzyme/test.jl

@@ -5,72 +5,48 @@ using ADTypes: ADTypes
 using DifferentiationInterface, DifferentiationInterfaceTest
 import DifferentiationInterfaceTest as DIT
 using Enzyme: Enzyme
-using SparseConnectivityTracer, SparseMatrixColorings
 using Test
 
 LOGGING = get(ENV, "CI", "false") == "false"
 
-dense_backends = [
+backends = [
     AutoEnzyme(; mode=nothing),
     AutoEnzyme(; mode=Enzyme.Forward),
     AutoEnzyme(; mode=Enzyme.Reverse),
     AutoEnzyme(; mode=Enzyme.Forward, function_annotation=Enzyme.Const),
     AutoEnzyme(; mode=Enzyme.Reverse, function_annotation=Enzyme.Const),
 ]
 
-duplicated_function_backends = [
+duplicated_backends = [
     AutoEnzyme(; mode=Enzyme.Forward, function_annotation=Enzyme.Duplicated),
     AutoEnzyme(; mode=Enzyme.Reverse, function_annotation=Enzyme.Duplicated),
 ]
 
-sparse_backends =
-    AutoSparse.(
-        dense_backends[1:3],
-        sparsity_detector=TracerSparsityDetector(),
-        coloring_algorithm=GreedyColoringAlgorithm(),
-    )
-
 @testset "Checks" begin
-    @testset "Check $(typeof(backend))" for backend in vcat(dense_backends, sparse_backends)
+    @testset "Check $(typeof(backend))" for backend in backends
         @test check_available(backend)
         @test check_inplace(backend)
     end
 end;
 
-## Dense backends
+## First order
 
-test_differentiation(
-    dense_backends, default_scenarios(); second_order=false, logging=LOGGING
-);
+test_differentiation(backends, default_scenarios(); second_order=false, logging=LOGGING);
 
 test_differentiation(
-    dense_backends[1:3],
+    backends[1:3],
     default_scenarios(; include_normal=false, include_constantified=true);
     second_order=false,
     logging=LOGGING,
 );
 
 test_differentiation(
-    duplicated_function_backends,
+    duplicated_backends,
     default_scenarios(; include_normal=false, include_closurified=true);
     second_order=false,
     logging=LOGGING,
 );
 
-test_differentiation(
-    [AutoEnzyme(; mode=nothing), AutoEnzyme(; mode=Enzyme.Reverse)];
-    first_order=false,
-    excluded=[:second_derivative],
-    logging=LOGGING,
-);
-
-test_differentiation(
-    [AutoEnzyme(; mode=nothing), AutoEnzyme(; mode=Enzyme.Forward)];
-    first_order=false,
-    excluded=[:hessian, :hvp],
-    logging=LOGGING,
-);
-
 #=
 # TODO: reactivate type stability tests
 
@@ -84,20 +60,37 @@ test_differentiation(
 );
 =#
 
-## Sparse backends
+## Second order
 
 test_differentiation(
-    sparse_backends,
-    default_scenarios();
-    excluded=[:derivative, :gradient, :pullback, :pushforward, :second_derivative, :hvp],
-    second_order=false,  # TODO: make true
+    AutoEnzyme(),
+    default_scenarios(; include_constantified=true);
+    first_order=false,
     logging=LOGGING,
 );
 
 test_differentiation(
-    sparse_backends,
-    sparse_scenarios();
-    sparsity=true,
-    second_order=false,  # TODO: make true
+    AutoEnzyme(; mode=Enzyme.Forward);
+    first_order=false,
+    excluded=[:hessian, :hvp],
+    logging=LOGGING,
+);
+
+test_differentiation(
+    AutoEnzyme(; mode=Enzyme.Reverse);
+    first_order=false,
+    excluded=[:second_derivative],
+    logging=LOGGING,
+);
+
+test_differentiation(
+    SecondOrder(AutoEnzyme(; mode=Enzyme.Reverse), AutoEnzyme(; mode=Enzyme.Forward));
+    first_order=false,
     logging=LOGGING,
 );
+
+## Sparse
+
+test_differentiation(
+    MyAutoSparse.(AutoEnzyme()), sparse_scenarios(); sparsity=true, logging=LOGGING
+);

DifferentiationInterface/test/Back/ForwardDiff/test.jl

@@ -4,30 +4,22 @@ Pkg.add("ForwardDiff")
 using ComponentArrays: ComponentArrays
 using DifferentiationInterface, DifferentiationInterfaceTest
 using ForwardDiff: ForwardDiff
-using SparseConnectivityTracer, SparseMatrixColorings
 using StaticArrays: StaticArrays
 using Test
 
 LOGGING = get(ENV, "CI", "false") == "false"
 
-dense_backends = [AutoForwardDiff(; tag=:hello), AutoForwardDiff(; chunksize=5)]
+backends = [AutoForwardDiff(; tag=:hello), AutoForwardDiff(; chunksize=5)]
 
-sparse_backends =
-    AutoSparse.(
-        dense_backends;
-        sparsity_detector=TracerSparsityDetector(),
-        coloring_algorithm=GreedyColoringAlgorithm(),
-    )
-
-for backend in vcat(dense_backends, sparse_backends)
+for backend in backends
     @test check_available(backend)
     @test check_inplace(backend)
 end
 
-## Dense backends
+## Dense
 
 test_differentiation(
-    dense_backends, default_scenarios(; include_constantified=true); logging=LOGGING
+    backends, default_scenarios(; include_constantified=true); logging=LOGGING
 );
 
 test_differentiation(
@@ -42,26 +34,19 @@ test_differentiation(
 );
 
 test_differentiation(
-    dense_backends,
-    # ForwardDiff accesses individual indices
-    vcat(component_scenarios(), static_scenarios());
-    # jacobian is super slow for some reason
-    excluded=[:jacobian],
+    backends,
+    vcat(component_scenarios(), static_scenarios()); # FD accesses individual indices
+    excluded=[:jacobian],  # jacobian is super slow for some reason
     second_order=false,
     logging=LOGGING,
 );
 
-## Sparse backends
+## Sparse
 
-test_differentiation(
-    sparse_backends,
-    default_scenarios();
-    excluded=[:derivative, :gradient, :hvp, :pullback, :pushforward, :second_derivative],
-    logging=LOGGING,
-);
+test_differentiation(MyAutoSparse.(backends), default_scenarios(); logging=LOGGING);
 
 test_differentiation(
-    sparse_backends,
+    MyAutoSparse.(backends),
     sparse_scenarios(; include_constantified=true);
     sparsity=true,
     logging=LOGGING,

DifferentiationInterface/test/Back/PolyesterForwardDiff/test.jl

@@ -18,7 +18,5 @@ for backend in backends
 end
 
 test_differentiation(
-    backends,  #
-    default_scenarios(; include_constantified=true);
-    logging=LOGGING,
+    backends, default_scenarios(; include_constantified=true); logging=LOGGING
 );

DifferentiationInterface/test/Back/ReverseDiff/test.jl

@@ -1,22 +1,37 @@
 using Pkg
-Pkg.add("ReverseDiff")
+Pkg.add(["ForwardDiff", "ReverseDiff"])  # ForwardDiff already in ReverseDiff's deps
 
 using DifferentiationInterface, DifferentiationInterfaceTest
+using ForwardDiff: ForwardDiff
 using ReverseDiff: ReverseDiff
 using StaticArrays: StaticArrays
 using Test
 
 LOGGING = get(ENV, "CI", "false") == "false"
 
-dense_backends = [AutoReverseDiff(; compile=false), AutoReverseDiff(; compile=true)]
+backends = [AutoReverseDiff(; compile=false), AutoReverseDiff(; compile=true)]
+second_order_backends = [SecondOrder(AutoForwardDiff(), AutoReverseDiff())]
 
-for backend in dense_backends
+for backend in vcat(backends, second_order_backends)
     @test check_available(backend)
     @test check_inplace(backend)
 end
 
+## Dense
+
 test_differentiation(
-    dense_backends, default_scenarios(; include_constantified=true); logging=LOGGING
+    vcat(backends, second_order_backends),
+    default_scenarios(; include_constantified=true);
+    logging=LOGGING,
 );
 
-test_differentiation(AutoReverseDiff(), static_scenarios(); logging=LOGGING);
+test_differentiation(backends[1], static_scenarios(); logging=LOGGING);
+
+## Sparse
+
+test_differentiation(
+    MyAutoSparse.(vcat(backends, second_order_backends)),
+    sparse_scenarios();
+    sparsity=true,
+    logging=LOGGING,
+);