Peformance Optimization (#138)

* use generated function to run instruction

* optimize mem allocation

* optiomize copy and update_var!

* optimization on constant

* remove MacroTools

* don't optimize function call

* opt const function-call conditionally

* remove `val`

* breakdown benchmarks

* use Vector as bindings

* use Int as box, inline _update_var! manually

* code refactor

* remove unused code

* Update src/tapedfunction.jl

* add comments

* update comments

* update from review

* update from review

* use a compact bindings, remove the offset limitation

* bugfix: unify TypedSlot and SlotNumber

* document

* refine types

* give bindings a sizehint

* update docs for `tape_copy`

* remove outdated comments

* update from review

* disable logging by default

* update comments

* use vector to store arg indices

* rename fields in TF

* remove TempBindings

* Update tapedfunction.jl

* Update Project.toml

Co-authored-by: Hong Ge <3279477+yebai@users.noreply.github.com>

Author: KDr2

Project.toml

@@ -3,7 +3,7 @@ uuid = "6f1fad26-d15e-5dc8-ae53-837a1d7b8c9f"
 license = "MIT"
 desc = "Tape based task copying in Turing"
 repo = "https://github.com/TuringLang/Libtask.jl.git"
-version = "0.7.3"
+version = "0.7.4"
 
 [deps]
 FunctionWrappers = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e"

perf/benchmark.jl

@@ -8,7 +8,7 @@ function benchmark_driver!(f, x...; f_displayname=string(f))
     x = (x..., nothing)
 
     println("benchmarking $(f_displayname)...")
-    tf = Libtask.TapedFunction(f, x...);
+    tf = Libtask.TapedFunction(f, x...)
 
     print("  Run Original Function:")
     @btime $f($(x)...)
@@ -24,18 +24,18 @@ function benchmark_driver!(f, x...; f_displayname=string(f))
     GC.gc()
 
     print("  Run TapedTask: ")
-    x = (x[1:end-1]..., produce);
+    x = (x[1:end-1]..., produce)
     # show the number of produce calls inside `f`
-    f_task = (f, x; verbose=false) -> begin 
-        tt = TapedTask(f, x...); 
+    function f_task(f, x; verbose=false)
+        tt = TapedTask(f, x...)
         c = 0
         while consume(tt)!==nothing
             c+=1
         end
-        verbose && print("#produce=", c, "; "); 
+        verbose && print("#produce=", c, "; ")
     end
-    # Note that we need to pass `f` instead of `tf` to avoid 
-    #  default continuation in `TapedTask` constructor, see, e.g. 
+    # Note that we need to pass `f` instead of `tf` to avoid
+    #  default continuation in `TapedTask` constructor, see, e.g.
     #  https://github.com/TuringLang/Libtask.jl/pull/135
     f_task(f, x; verbose=true) # print #produce calls
     @btime $f_task($f, $x)
@@ -109,4 +109,17 @@ benchmark_driver!(neural_net, xs...)
 
 ####################################################################
 
+println("======= breakdown benchmark =======")
+
+x = rand(100000)
+tf = Libtask.TapedFunction(ackley, x, nothing)
+tf(x, nothing);
+ins = tf.tape[45]
+b = ins.input[1]
+
+@show ins.input |> length
+@btime map(x -> Libtask._lookup(tf, x), ins.input)
+@btime Libtask._lookup(tf, b)
+@btime tf.binding_values[b]
+
 println("done")