Precompiling a function which spawns a Task does not precompile the Task's function

[NHDaly]

Precompiling a function which spawns a Task does not precompile the Task's function.

Normally, precompiling a function will also compile all statically reachable functions it could call. However, since the function itself doesn't invoke the anonymous function it creates for a Task it spawns, that function is not compiled.

Consider this small MRE ran with --trace-compile=stderr:

julia> bar() = println("HI")
bar (generic function with 1 method)

julia> foo() = Threads.@spawn bar()
foo (generic function with 1 method)

julia> precompile(foo, ())
#=    6.6 =# precompile(Tuple{typeof(Main.foo)})
true

# Note that this _could_ have also compiled the lambda #foo##4#foo##5 which calls 
# bar(), but it did not.

# Now, actually _calling_ the function, which causes the Task to get scheduled,
# does precompile that lambda when the Task is first executed:

julia> foo()
#=    4.6 =# precompile(Tuple{Main.var"#foo##4#foo##5"})
HI
Task (done) @0x00000001662fb2d0

This makes it difficult to precompile such functions during the Package Precompilation step, without actually running a snoop workload.

Thanks!

[vchuravy]

IIRC this is partially intended since the task may never be executed and it could (eventually) lead to the inference work being parallelized since the task can get picked up by a worker and is naturally parallel.

It reduces the inference latency of the parent and currently the information is not being used.

The downside is that you may get a stampede for @threads were every worker thread hits the inference and compilation lock.

[NHDaly]

Interesting! Yeah, those are all very good motivations I think, but it seems to me that they mostly apply only to JIT-mode. Do you think we could make a different choice in the AoT compilation mode?

[NHDaly]

The downside is that you may get a stampede for @threads were every worker thread hits the inference and compilation lock.

On master, I think this could also be lower-latency overall if the compilation job is very large, since those threads are all able to pick up and parallelize the LLVM module compilation jobs now, i think?

[JeffBezanson]

This is also needed for trimming. Can be handled similarly to finalizers. We should precompile it when generating binaries, but possibly just all the time as well.

[NHDaly]

CC: @gbaraldi for the trimming aspect