added functions for easily comparing Dual vs. GradientNumber performance and codegen

Author: jrevels

benchmarks/benchmarks.jl

@@ -5,7 +5,15 @@ using JLD
 ##################
 # Test functions #
 ##################
-sqr(i) = i*i
+function rosenbrock(x)
+    a = one(eltype(x))
+    b = 100 * a
+    result = zero(eltype(x))
+    for i in 1:length(x)-1
+        result += (a - x[i])^2 + b*(x[i+1] - x[i]^2)^2
+    end
+    return result
+end
 
 function ackley(x)
     a, b, c = 20.0, -0.2, 2.0*π
@@ -14,21 +22,12 @@ function ackley(x)
     sum_cos = sum_sqrs
     for i in x
         sum_cos += cos(c*i)
-        sum_sqrs += sqr(i)
+        sum_sqrs += i^2
     end
     return (-a * exp(b * sqrt(len_recip*sum_sqrs)) -
             exp(len_recip*sum_cos) + a + e)
 end
 
-function rosenbrock(x)
-    a, b = 100.0, 1.0
-    result = zero(eltype(x))
-    for i in 1:length(x)-1
-        result += sqr(b - x[i]) + a*sqr(x[i+1] - sqr(x[i]))
-    end
-    return result
-end
-
 self_weighted_logit(x) = inv(1.0 + exp(-dot(x, x)))
 
 #############################

benchmarks/gradnums_vs_duals.jl

@@ -0,0 +1,43 @@
+using ForwardDiff.GradientNumber
+using DualNumbers
+
+# cmp_codegen(f) should report fairly similar code for 
+# Duals and GradientNumbers, possibly with a few extra 
+# allocations due to the Partials layer
+#
+# cmp_times(f) should report similar times for Duals 
+# and GradientNumbers (within a few percent difference)
+
+function cmp_codegen(f)
+    x = rand(3);
+    dx = map(dual, x);
+    ndx = map(i->GradientNumber(i, zero(i)), x);
+
+    info("@code_llvm $(f)(::Vector{Dual{Float64}}):")
+    @code_llvm f(dx)
+
+    println()
+
+    info("@code_llvm $(f)(::Vector{GradientNumber{1,Float64,Tuple{Float64}}}):")
+    @code_llvm f(ndx)
+end
+
+function cmp_times(f, xlen, repeat=5)
+    x = rand(xlen);
+    dx = map(dual, x);
+    ndx = map(i->GradientNumber(i, zero(i)), x);
+
+    min_time_dual = Inf
+    min_time_gradnum = Inf
+
+    for i in 1:(repeat+1) # +1 for warm-up
+        gc()
+        this_time_dual = @elapsed f(dx)
+        this_time_gradnum = @elapsed f(ndx)
+        min_time_dual = min(this_time_dual, min_time_dual)
+        min_time_gradnum = min(this_time_gradnum, min_time_gradnum)
+    end
+
+    println("Time for $(f)(::Vector{Dual{Float64}}): $min_time_dual seconds")
+    println("Time for $(f)(::Vector{GradientNumber{1,Float64,Tuple{Float64}}}): $min_time_gradnum seconds")
+end