delay -> offset

src/compiler/code.jl

@@ -6,7 +6,7 @@ export @net
 
 function process_func(ex, params = [])
   @capture(shortdef(ex), (args__,) -> body_)
-  body = @> body MacroTools.flatten liftloops!(params) graphm DataFlow.il
+  body = @> body MacroTools.flatten liftloops(params) graphm DataFlow.il
   body = mapconst(x -> x in params ? :(self.$x) : x, body)
   return args, body
 end
@@ -15,7 +15,7 @@ function makegraph(graph, args)
   @assert length(args) == 1
   mapconst(graph) do x
     x == args[1] ? inputnode(1) :
-    isa(x, Delay) ? :(Delay($(Expr(:quote, x.name)), self.$(x.name))) :
+    isa(x, Offset) ? :(Offset($(Expr(:quote, x.name)), $(x.n), self.$(x.name))) :
     x
   end
 end

src/compiler/loops.jl

@@ -1,26 +1,19 @@
 export unroll
 
-type Delay
+type Offset
   name::Symbol
+  n::Int
   default::Nullable{Param}
 end
 
-Delay(name) = Delay(name, nothing)
+Offset(name, n) = Offset(name, n, nothing)
 
-function liftloops!(ex, params)
+function liftloops(ex, params)
   ex = DataFlow.normedges(ex)
-  hidden = intersect((b.args[1] for b in ex.args), params)
+  MacroTools.postwalk(ex) do ex
-  edges = Dict(h => gensym("edge") for h in hidden)
+    @capture(ex, x_{n_}) || return ex
-  declared = Dict(h => false for h in hidden)
+    :($(Offset(x,n))($x))
-  liftvar(s) = get(declared, s, false) ? s : get(edges, s, s)
-  for b in ex.args
-    b.args[2] = MacroTools.postwalk(liftvar, b.args[2])
-    declared[b.args[1]] = true
   end
-  for (h, e) in edges
-    unshift!(ex.args, :($e = $(Delay(h))($h)))
-  end
-  return ex
 end
 
 function hasloops(model)
@@ -39,39 +32,39 @@ function atomise(model)
   end
 end
 
-hiddeninput(n) = vertex(Split(n), inputnode(1))
+# hiddeninput(n) = vertex(Split(n), inputnode(1))
-
+#
-function unroll!(delay::IVertex, n)
+# function unroll!(delay::IVertex, n)
-  prewalk!(delay[1]) do v
+#   prewalk!(delay[1]) do v
-    v === delay ? hiddeninput(n) : v
+#     v === delay ? hiddeninput(n) : v
-  end
+#   end
-end
+# end
-
+#
-function break!(g::IVertex)
+# function break!(g::IVertex)
-  g = bumpinputs(g)
+#   g = bumpinputs(g)
-  loops = []
+#   loops = []
-  defaults = []
+#   defaults = []
-  g = prewalk!(g) do v
+#   g = prewalk!(g) do v
-    isa(value(v), Delay) || return v
+#     isa(value(v), Offset) || return v
-    n = length(loops)+1
+#     n = length(loops)+1
-    push!(loops, unroll!(v, n))
+#     push!(loops, unroll!(v, n))
-    push!(defaults, get(value(v).default))
+#     push!(defaults, get(value(v).default))
-    hiddeninput(n)
+#     hiddeninput(n)
-  end
+#   end
-  cse(group(group(loops...), g)), defaults
+#   cse(group(group(loops...), g)), defaults
-end
+# end
-
+#
-function unrollgraph(model, n)
+# function unrollgraph(model, n)
-  graph, defaults = break!(atomise(model))
+#   graph, defaults = break!(atomise(model))
-  outputs = [spliceinputs(graph, group([constant(splitnode(inputnode(1),i)) for i = 1:length(defaults)]...),
+#   outputs = [spliceinputs(graph, group([constant(splitnode(inputnode(1),i)) for i = 1:length(defaults)]...),
-                                 splitnode(inputnode(2), 1))]
+#                                  splitnode(inputnode(2), 1))]
-  for i = 2:n
+#   for i = 2:n
-    push!(outputs, spliceinputs(graph, outputs[end][1], splitnode(inputnode(2), i)))
+#     push!(outputs, spliceinputs(graph, outputs[end][1], splitnode(inputnode(2), i)))
-  end
+#   end
-  state = outputs[end][1]
+#   state = outputs[end][1]
-  outputs = map(x -> x[2], outputs)
+#   outputs = map(x -> x[2], outputs)
-  (@> group(state, group(outputs...)) detuple), map(x->x.x, defaults)
+#   (@> group(state, group(outputs...)) detuple), map(x->x.x, defaults)
-end
+# end
 
 type Unrolled <: Model
   model