Merge pull request #222 from JuliaSymbolics/s/spawn-fetch-args

make SpawnFetch take Func expressions and arguments

Author: shashi

src/code.jl

@@ -464,23 +464,33 @@ end
 
 struct Multithreaded end
 """
-    SpawnFetch{ParallelType}(exprs, reduce)
+    SpawnFetch{ParallelType}(funcs [, args], reduce)
 
-Run every expr in `exprs` in its own task, and use the `reduce`
-function to combine the results of executing `exprs`.
+Run every expression in `funcs` in its own task, the expression
+should be a `Func` object and is passed to `Threads.Task(f)`.
+If `Func` takes arguments, then the arguments must be passed in as `args`--a vector of vector of arguments to each function in `funcs`. We don't use `@spawn` in order to support RuntimeGeneratedFunctions which disallow closures, instead we interpolate these functions or closures as smaller RuntimeGeneratedFunctions.
+
+`reduce` function is used to combine the results of executing `exprs`. A SpawnFetch expression returns the reduced result.
+
+
+Use `Symbolics.MultithreadedForm` ParallelType from the Symbolics.jl package to get the RuntimeGeneratedFunction version SpawnFetch.
 
 `ParallelType` can be used to define more parallelism types
 SymbolicUtils supports `Multithreaded` type. Which spawns
 threaded tasks.
 """
 struct SpawnFetch{Typ}
     exprs::Vector
+    args::Union{Nothing, Vector}
     combine
 end
 
+(::Type{SpawnFetch{T}})(exprs, combine) where {T} = SpawnFetch{T}(exprs, nothing, combine)
+
 function toexpr(p::SpawnFetch{Multithreaded}, st)
-    spawns = map(p.exprs) do thunk
-        :(Base.Threads.@spawn $(toexpr(thunk, st)))
+    args = isnothing(p.args) ? Iterators.repeated((), length(p.exprs)) : p.args
+    spawns = map(p.exprs, args) do thunk, xs
+        :(Base.Threads.@spawn $(toexpr(thunk, st))($(toexpr.(xs, (st,))...)))
     end
     quote
         $(toexpr(p.combine, st))(map(fetch, ($(spawns...),))...)

test/code.jl

@@ -124,7 +124,13 @@ test_repr(a, b) = @test repr(Base.remove_linenums!(a)) == repr(Base.remove_linen
     test_repr(toexpr(MakeTuple((a, b, a+b))),
               :((a,b,$(+)(a,b))))
 
-    @test SpawnFetch{Multithreaded}([1,2],vcat)|>toexpr|>eval == [1,2]
-    @test @elapsed(SpawnFetch{Multithreaded}([:(sleep(.3)),:(sleep(.6))],vcat)|>toexpr|>eval) < 0.8
+    @test SpawnFetch{Multithreaded}([()->1,()->2],vcat)|>toexpr|>eval == [1,2]
+    @test @elapsed(SpawnFetch{Multithreaded}([:(()->sleep(.6)),
+                                              Func([:x],
+                                                   [],
+                                                   :(sleep(x)))],
+                                             [(),
+                                              (0.6,)],
+                                             vcat)|>toexpr|>eval) < 1.1
 end