Completely Refactor

.JuliaFormatter.toml

@@ -0,0 +1 @@
+style = "blue"

.github/workflows/Testing.yaml

@@ -11,7 +11,6 @@ jobs:
     strategy:
       matrix:
         version:
-          - '1.7'
           - '1.10'
           - '1'
           - 'nightly'

.gitignore

@@ -1,60 +1,3 @@
-# Prerequisites
-*.d
-
-# Object files
-*.o
-*.ko
-*.obj
-*.elf
-
-# Linker output
-*.ilk
-*.map
-*.exp
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Libraries
-*.lib
-*.a
-*.la
-*.lo
-
-# Shared objects (inc. Windows DLLs)
-*.dll
-*.so
-*.so.*
-*.dylib
-
-# Executables
-*.exe
-*.out
-*.app
-*.i*86
-*.x86_64
-*.hex
-
-# Debug files
-*.dSYM/
-*.su
-*.idb
-*.pdb
-
-# Kernel Module Compile Results
-*.mod*
-*.cmd
-.tmp_versions/
-modules.order
-Module.symvers
-Mkfile.old
-dkms.conf
-
 # Projects files
 Manifest.toml
-deps/build.log
-deps/deps.jl
-deps/usr/
-deps/tmp-build.jl
 *.cov

Project.toml

@@ -6,19 +6,22 @@ repo = "https://github.com/TuringLang/Libtask.jl.git"
 version = "0.8.8"
 
 [deps]
-FunctionWrappers = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e"
-LRUCache = "8ac3fa9e-de4c-5943-b1dc-09c6b5f20637"
-LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+MistyClosures = "dbe65cb8-6be2-42dd-bbc5-4196aaced4f4"
+Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
-FunctionWrappers = "1.1"
-LRUCache = "1.3"
-julia = "1.7"
+Aqua = "0.8.11"
+JuliaFormatter = "1.0.62"
+MistyClosures = "2.0.0"
+Mooncake = "0.4.99"
+Test = "1"
+julia = "1.10.8"
 
 [extras]
-BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
+Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
+JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "BenchmarkTools"]
+test = ["Aqua", "JuliaFormatter", "Test"]

README.md

@@ -97,3 +97,5 @@ Notes:
   to a tape and copying that tape. Before that version, it is based on
   a tricky hack on the Julia internals. You can check the commit
   history of this repo to see the details.
+
+- From version 0.9.0, the old `TArray` and `TRef` types are completely removed, where previously they were deprecated.

perf/Project.toml

@@ -8,7 +8,7 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 Turing = "fce5fe82-541a-59a6-adf8-730c64b5f9a0"
 
 [compat]
-julia = "1.3"
+julia = "1.10.8"
 
 [targets]
 test = ["Test", "BenchmarkTools"]

perf/benchmark.jl

@@ -24,31 +24,31 @@ 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`
     function f_task(f, x; verbose=false)
         tt = TapedTask(f, x...)
         c = 0
-        while consume(tt)!==nothing
-            c+=1
+        while consume(tt) !== nothing
+            c += 1
         end
-        verbose && print("#produce=", c, "; ")
+        return 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.
     #  https://github.com/TuringLang/Libtask.jl/pull/135
     f_task(f, x; verbose=true) # print #produce calls
     @btime $f_task($f, $x)
     GC.gc()
+    return nothing
 end
 
 ####################################################################
 
-
 function rosenbrock(x, callback=nothing)
     i = x[2:end]
-    j = x[1:end-1]
-    ret = sum((1 .- j).^2 + 100*(i - j.^2).^2)
+    j = x[1:(end - 1)]
+    ret = sum((1 .- j) .^ 2 + 100 * (i - j .^ 2) .^ 2)
     callback !== nothing && callback(ret)
     return ret
 end
@@ -59,17 +59,20 @@ benchmark_driver!(rosenbrock, x)
 ####################################################################
 
 function ackley(x::AbstractVector, callback=nothing)
-    a, b, c = 20.0, -0.2, 2.0*π
+    a, b, c = 20.0, -0.2, 2.0 * π
     len_recip = inv(length(x))
     sum_sqrs = zero(eltype(x))
     sum_cos = sum_sqrs
     for i in x
-        sum_cos += cos(c*i)
+        sum_cos += cos(c * i)
         sum_sqrs += i^2
         callback !== nothing && callback(sum_sqrs)
     end
-    return (-a * exp(b * sqrt(len_recip*sum_sqrs)) -
-            exp(len_recip*sum_cos) + a + MathConstants.e)
+    return (
+        -a * exp(b * sqrt(len_recip * sum_sqrs)) - exp(len_recip * sum_cos) +
+        a +
+        MathConstants.e
+    )
 end
 
 x = rand(100000)
@@ -79,8 +82,8 @@ benchmark_driver!(ackley, x)
 function generate_matrix_test(n)
     return (x, callback=nothing) -> begin
         # @assert length(x) == 2n^2 + n
-        a = reshape(x[1:n^2], n, n)
-        b = reshape(x[n^2 + 1:2n^2], n, n)
+        a = reshape(x[1:(n^2)], n, n)
+        b = reshape(x[(n^2 + 1):(2n^2)], n, n)
         ret = log.((a * b) + a - b)
         callback !== nothing && callback(ret)
         return ret
@@ -94,7 +97,7 @@ benchmark_driver!(matrix_test, x; f_displayname="matrix_test")
 
 ####################################################################
 relu(x) = log.(1.0 .+ exp.(x))
-sigmoid(n) = 1. / (1. + exp(-n))
+sigmoid(n) = 1.0 / (1.0 + exp(-n))
 
 function neural_net(w1, w2, w3, x1, callback=nothing)
     x2 = relu(w1 * x1)
@@ -104,7 +107,7 @@ function neural_net(w1, w2, w3, x1, callback=nothing)
     return ret
 end
 
-xs = (randn(10,10), randn(10,10), randn(10), rand(10))
+xs = (randn(10, 10), randn(10, 10), randn(10), rand(10))
 benchmark_driver!(neural_net, xs...)
 
 ####################################################################
@@ -114,11 +117,11 @@ println("======= breakdown benchmark =======")
 x = rand(100000)
 tf = Libtask.TapedFunction(ackley, x, nothing)
 tf(x, nothing);
-idx = findlast((x)->isa(x, Libtask.Instruction), tf.tape)
+idx = findlast((x) -> isa(x, Libtask.Instruction), tf.tape)
 ins = tf.tape[idx]
 b = ins.input[1]
 
-@show ins.input |> length
+@show length(ins.input)
 @btime map(x -> Libtask._lookup(tf, x), ins.input)
 @btime Libtask._lookup(tf, b)
 @btime tf.binding_values[b]

perf/p0.jl

@@ -5,17 +5,16 @@ using BenchmarkTools
 
 @model gdemo(x, y) = begin
     # Assumptions
-    σ ~ InverseGamma(2,3)
-    μ ~ Normal(0,sqrt(σ))
+    σ ~ InverseGamma(2, 3)
+    μ ~ Normal(0, sqrt(σ))
     # Observations
     x ~ Normal(μ, sqrt(σ))
     y ~ Normal(μ, sqrt(σ))
 end
 
-
 # Case 1: Sample from the prior.
 rng = MersenneTwister()
-m = Turing.Core.TracedModel(gdemo(1.5, 2.), SampleFromPrior(), VarInfo(), rng)
+m = Turing.Core.TracedModel(gdemo(1.5, 2.0), SampleFromPrior(), VarInfo(), rng)
 f = m.evaluator[1];
 args = m.evaluator[2:end];
 
@@ -28,7 +27,7 @@ println("Run a tape...")
 @btime t.tf(args...)
 
 # Case 2: SMC sampler
-m = Turing.Core.TracedModel(gdemo(1.5, 2.), Sampler(SMC(50)), VarInfo(), rng)
+m = Turing.Core.TracedModel(gdemo(1.5, 2.0), Sampler(SMC(50)), VarInfo(), rng)
 f = m.evaluator[1];
 args = m.evaluator[2:end];
 

perf/p1.jl

@@ -2,25 +2,22 @@ using Turing, Test, AbstractMCMC, DynamicPPL, Random
 
 import AbstractMCMC.AbstractSampler
 
-function check_numerical(chain,
-                         symbols::Vector,
-                         exact_vals::Vector;
-                         atol=0.2,
-                         rtol=0.0)
+function check_numerical(chain, symbols::Vector, exact_vals::Vector; atol=0.2, rtol=0.0)
     for (sym, val) in zip(symbols, exact_vals)
-        E = val isa Real ?
-            mean(chain[sym]) :
-            vec(mean(chain[sym], dims=1))
+        E = val isa Real ? mean(chain[sym]) : vec(mean(chain[sym]; dims=1))
         @info (symbol=sym, exact=val, evaluated=E)
-        @test E ≈ val atol=atol rtol=rtol
+        @test E ≈ val atol = atol rtol = rtol
     end
 end
 
 function check_MoGtest_default(chain; atol=0.2, rtol=0.0)
-    check_numerical(chain,
-                    [:z1, :z2, :z3, :z4, :mu1, :mu2],
-                    [1.0, 1.0, 2.0, 2.0, 1.0, 4.0],
-                    atol=atol, rtol=rtol)
+    return check_numerical(
+        chain,
+        [:z1, :z2, :z3, :z4, :mu1, :mu2],
+        [1.0, 1.0, 2.0, 2.0, 1.0, 4.0];
+        atol=atol,
+        rtol=rtol,
+    )
 end
 
 @model gdemo_d(x, y) = begin
@@ -36,4 +33,4 @@ chain = sample(gdemo_d(1.5, 2.0), alg, 5_000)
 
 @show chain
 
-check_numerical(chain, [:s, :m], [49/24, 7/6], atol=0.1)
+check_numerical(chain, [:s, :m], [49 / 24, 7 / 6]; atol=0.1)

src/Libtask.jl

@@ -1,26 +1,20 @@
 module Libtask
 
-using FunctionWrappers: FunctionWrapper
-using LRUCache
+# Need this for BBCode.
+using Mooncake
+using Mooncake: BBCode, BBlock, ID, new_inst, stmt, seed_id!
+using Mooncake: IDGotoIfNot, IDGotoNode, IDPhiNode, Switch
 
-export TapedTask, consume, produce
-
-export TArray, tzeros, tfill, TRef # legacy types back compat
+# We'll emit `MistyClosure`s rather than `OpaqueClosure`s.
+using MistyClosures
 
+# Import some names from the compiler.
+const CC = Core.Compiler
+using Core.Compiler: Argument, IRCode, ReturnNode
 
-@static if isdefined(Core, :TypedSlot) || isdefined(Core.Compiler, :TypedSlot)
-    # Julia v1.10 moved Core.TypedSlot to Core.Compiler
-    # Julia v1.11 removed Core.Compiler.TypedSlot
-    const TypedSlot = @static if isdefined(Core, :TypedSlot)
-        Core.TypedSlot
-    else
-        Core.Compiler.TypedSlot
-    end
-else
-    struct TypedSlot end # Dummy
-end
+include("copyable_task.jl")
+include("test_utils.jl")
 
-include("tapedfunction.jl")
-include("tapedtask.jl")
+export TapedTask, consume, produce
 
 end