remove compat layer for benchmarking

Author: hexaeder

benchmark/benchmark_compat.jl

@@ -1,75 +1,12 @@
 #=
-Helper functions to create compatible states between NetworkDynamics.jl and NetworkDynamics.jl v0.8
+Helper functions to create compatible states between newer and older versions of NetworkDynamics.jl
+for cross version benchmarking.
 =#
 
-if pkgversion(NetworkDynamics) < v"0.9.0"
-    @info "Define compatibility functions"
-    struct Network end
-    struct SequentialExecution{P} end
-    struct KAExecution{P} end
-    struct PolyesterExecution{P} end
-    struct ThreadedExecution{P} end
-    struct KAAggregator; f; end
-    struct SequentialAggregator; f; end
-    struct PolyesterAggregator; f; end
-    struct ThreadedAggregator; f; end
-    function Network(g, v, e; execution = SequentialExecution{true}(), aggregator=SequentialAggregator(+))
-        if execution isa PolyesterExecution{true} && aggregator isa PolyesterAggregator
-            network_dynamics(v, e, g; parallel=true)
-        elseif execution isa SequentialExecution{true} && aggregator isa SequentialAggregator
-            network_dynamics(v, e, g; parallel=false)
-        else
-            error("execution type not supported")
-        end
-    end
-elseif pkgversion(NetworkDynamics) < v"0.9.1"
-    isdynamic = NetworkDynamics.isdynamic
-else
-    isdynamic(_) = true
-end
-
-function _syms_old_order(nd::Network)
-    syms = []
-    for (i,cf) in enumerate(nd.im.vertexm)
-        isdynamic(cf) || continue
-        append!(syms, collect(VIndex(i, 1:dim(cf))))
-    end
-    for (i,cf) in enumerate(nd.im.edgem)
-        isdynamic(cf) || continue
-        append!(syms, collect(EIndex(i, 1:dim(cf))))
-    end
-    syms
-end
-function _psyms_old_order(nd::Network)
-    syms = []
-    for (i,cf) in enumerate(nd.im.vertexm)
-        append!(syms, collect(VPIndex(i, 1:pdim(cf))))
-    end
-    for (i,cf) in enumerate(nd.im.edgem)
-        append!(syms, collect(EPIndex(i, 1:pdim(cf))))
-    end
-    syms
-end
 function randx0(nd::Network)
     rng = StableRNG(1)
-    _x0 = rand(rng, dim(nd))
-
-    s = NWState(nd; utype=typeof(_x0))
-    for (i,sym) in enumerate(_syms_old_order(nd::Network))
-        s[sym] = _x0[i]
-    end
-    s[:]
+    rand(rng, dim(nd))
 end
-randx0(nd::ODEFunction) = rand(StableRNG(1), length(nd.syms))
-function legacy_order(nd::Network, _dx)
-    s = NWState(nd, _dx)
-    dx = similar(_dx)
-    for (i,sym) in enumerate(_syms_old_order(nd::Network))
-        dx[i] = s[sym]
-    end
-    dx
-end
-legacy_order(nd::ODEFunction, dx) = dx
 
 function randp(nd::Network)
     rng = StableRNG(1)
@@ -80,9 +17,3 @@ function randp(nd::Network)
     end
     p[:]
 end
-function randp(nd::ODEFunction)
-    rng = StableRNG(1)
-    g = nd.f.graph
-    _p = rand(rng, nv(g) + ne(g))
-    p = (_p[1:nv(g)], _p[nv(g)+1:end])
-end

benchmark/benchmark_models_v0.8.jl

@@ -18,13 +18,7 @@ using CUDA: adapt
 using ThreadPinning
 pinthreads(:cores)
 
-if pkgversion(NetworkDynamics) < v"0.9.0"
-    (isinteractive() ? includet : include)("benchmark_models_v0.8.jl")
-elseif pkgversion(NetworkDynamics) < v"0.9.1"
-    (isinteractive() ? includet : include)("benchmark_models_v0.9.jl")
-else
-    (isinteractive() ? includet : include)("benchmark_models.jl")
-end
+(isinteractive() ? includet : include)("benchmark_models.jl")
 
 @info "Benchmark with $(Threads.nthreads()) threads"
 
@@ -116,7 +110,7 @@ for k in keys(edges)
             @test dx ≈ _dx
 
             b = @be $nd($dx, $_x0, nothing, 0.0) seconds=SECONDS
-            br = BenchmarkResult(b, legacy_order(nd, dx))
+            br = BenchmarkResult(b, dx)
             bd["diffusion_"*k, exname, aggname, N] = br
 
             if CUDA.functional() && iscudacompatible(execution) && iscudacompatible(nd.layer.aggregator)
@@ -134,7 +128,7 @@ for k in keys(edges)
                 b = @be $nd_d($dx_d, $x0_d, nothing, 0.0) seconds=SECONDS
                 # we store the original _dx in the benchmarks results because we know
                 # our dx_d does not have the precision
-                br = BenchmarkResult(b, legacy_order(nd, _dx))
+                br = BenchmarkResult(b, _dx)
                 bd["diffusion_"*k, exname*"_cuda32", aggname*"_cuda32", N] = br
 
                 to = CuArray{Float64}
@@ -146,7 +140,7 @@ for k in keys(edges)
                 @test Vector(dx_d) ≈ _dx
 
                 b = @be $nd_d($dx_d, $x0_d, nothing, 0.0) seconds=SECONDS
-                br = BenchmarkResult(b, legacy_order(nd, Vector(dx_d)))
+                br = BenchmarkResult(b, Vector(dx_d))
                 bd["diffusion_"*k, exname*"_cuda64", aggname*"_cuda64", N] = br
             end
         end
@@ -213,7 +207,7 @@ for f in [homogeneous, heterogeneous]
             @test dx ≈ _dx
 
             b = @be $nd($dx, $_x0, $p, 0.0) seconds=SECONDS
-            br = BenchmarkResult(b, legacy_order(nd, dx))
+            br = BenchmarkResult(b, dx)
             bd["kuramoto_"*name, exname, aggname, N] = br
 
             if CUDA.functional() && iscudacompatible(execution) && iscudacompatible(nd.layer.aggregator)
@@ -232,7 +226,7 @@ for f in [homogeneous, heterogeneous]
                 b = @be $nd_d($dx_d, $x0_d, $p_d, 0.0) seconds=SECONDS
                 # we store the original _dx in the benchmarks results because we know
                 # our dx_d does not have the precision
-                br = BenchmarkResult(b, legacy_order(nd, _dx))
+                br = BenchmarkResult(b, _dx)
                 bd["kuramoto_"*name, exname*"_cuda32", aggname*"_cuda32", N] = br
 
                 to = CuArray{Float64}
@@ -245,7 +239,7 @@ for f in [homogeneous, heterogeneous]
                 @test Vector(dx_d) ≈ _dx
 
                 b = @be $nd_d($dx_d, $x0_d, $p_d, 0.0) seconds=SECONDS
-                br = BenchmarkResult(b, legacy_order(nd, Vector(dx_d)))
+                br = BenchmarkResult(b, Vector(dx_d))
                 bd["kuramoto_"*name, exname*"_cuda64", aggname*"_cuda64", N] = br
             end
         end
@@ -305,7 +299,7 @@ for N in Ns
         @test dx ≈ _dx
 
         b = @be $nd($dx, $_x0, $p, 0.0) seconds=SECONDS
-        br = BenchmarkResult(b, legacy_order(nd, dx))
+        br = BenchmarkResult(b, dx)
         bd["powergrid", exname, aggname, N] = br
 
         if CUDA.functional() && iscudacompatible(execution) && iscudacompatible(nd.layer.aggregator)
@@ -324,7 +318,7 @@ for N in Ns
             b = @be $nd_d($dx_d, $x0_d, $p_d, 0.0) seconds=SECONDS
             # we store the original _dx in the benchmarks results because we know
             # our dx_d does not have the precision
-            br = BenchmarkResult(b, legacy_order(nd, _dx))
+            br = BenchmarkResult(b, _dx)
             bd["powergrid", exname*"_cuda32", aggname*"_cuda32", N] = br
 
             to = CuArray{Float64}
@@ -337,7 +331,7 @@ for N in Ns
             @test Vector(dx_d) ≈ _dx
 
             b = @be $nd_d($dx_d, $x0_d, $p_d, 0.0) seconds=SECONDS
-            br = BenchmarkResult(b, legacy_order(nd, Vector(dx_d)))
+            br = BenchmarkResult(b, Vector(dx_d))
             bd["powergrid", exname*"_cuda64", aggname*"_cuda64", N] = br
         end
     end