Subtape + Fix Recursion

[markus7800]

Hello,

I am not too familiar with the code base, but I updated the subtaping functionality to work for my own project.
Maybe you find these fixes useful.

• Added subtapes property to TapedFunction
  This is important for task copying to work. We also have to copy the subtapes to continue in the correct instruction in the copied task (e.g. if we want to continue in a subtape).
• Remove translation optimisation based on constant return types of calls. A call may contain a produce statement but returns a constant. In the old implementation this call would have been optimised.
• Added a few test cases for subtapes that did not pass in the old implementation, but now do.

Best,
Markus

[torfjelde]

Hey Markus!

First of all, thank you for helping out with this!

Because my familiarity with Libtask is pretty bad, I'm just leaving some comments + trying to understand what's going on here; I'll leave the approval to someone else:)

Am I understanding it correctly that we need to keep the subtapes around because of scenarios such as the following. Suppose we have

function f()
    produce(1)
    g()
    produce(2)
end

function g()
    produce(3)
    produce(4)
    produce(5)
end

Libtask.is_primitive(::typeof(g), args...) = false

and we decide to make a copy after hitting produce(4). If we then try to execute the instruction for g in f again, we'll end up constructing an entirely new instance of instruction g (in the current version, not yours) and so will start from produce(4) again rather than produce(5)?

EDIT: Simpler example (on #subtape, not this branch)

julia> using Libtask

julia> f() = g()
f (generic function with 1 method)

julia> function g()
           produce(1)
           produce(2)
       end
g (generic function with 1 method)

julia> Libtask.is_primitive(::typeof(g), args...) = false

julia> ttask = TapedTask(f);

julia> iterate(ttask)
(1, nothing)

julia> iterate(ttask)
(2, nothing)

julia> ttask2 = copy(ttask);

julia> iterate(ttask2)  #  BAD: starts from the beginning of `g` 
(1, nothing)

On this branch:

julia> using Libtask

julia> f() = g()
f (generic function with 1 method)

julia> function g()
           produce(1)
           produce(2)
       end
g (generic function with 1 method)

julia> Libtask.is_primitive(::typeof(g), args...) = false

julia> ttask = TapedTask(f);

julia> iterate(ttask)
(1, nothing)

julia> consume(ttask)
(2, nothing)

julia> ttask2 = copy(ttask);

julia> iterate(ttask2)  #  GOOD: does the right thing!
(nothing, nothing)

EDIT 2: The "Copying task with subtapes" test in this PR is showing the exact same thing as the above 🤦

[torfjelde]

IIUC continuation=true is now needed because we might be calling the same TapedFunction multiple times?

EDIT: In contrast to before when were just constructing a new one every time.

[markus7800]

I think your understanding is correct.

In the tape, a function call constitutes a single instruction.
Previous to my changes, this function call was only allowed to call produce(val) once.
I think the reason was that without subtapes, we were only able to continue the execution after the call instruction.
This was safe to do if we only allow one produce and throw an error otherwise.

By flagging a function g as non-primitive is_primitive(typeof(g),...) = false, we tell Libtask that we want to be able to interrupt the execution in g (e.g. at produce(4)).

For this to work any parent tape function f (the caller) has to actually own the subtape of g.
The instruction counter of g has to be preserved, such that with continuation=true we continue exactly at the correct instruction in g. And yes, g is called multiple times with an updated counter.

Thus, when we fork/copy a task, we also have to copy all subtapes with their counters.

Also, when reusing a cached tape we have to reset all the counters of the subtapes counter = 1

[torfjelde]

That makes sense; thank you! And again, great work:)