Merge pull request #595 from SciML/runtime_generated

replace GenearlizedGenerated with RuntimeGeneratedFunctions

Author: ChrisRackauckas

Project.toml

@@ -11,7 +11,6 @@ DiffEqJump = "c894b116-72e5-5b58-be3c-e6d8d4ac2b12"
 DiffRules = "b552c78f-8df3-52c6-915a-8e097449b14b"
 Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
-GeneralizedGenerated = "6b9d7cbe-bcb9-11e9-073f-15a7a543e2eb"
 IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
 LabelledArrays = "2ee39098-c373-598a-b85f-a56591580800"
 Latexify = "23fbe1c1-3f47-55db-b15f-69d7ec21a316"
@@ -22,6 +21,7 @@ MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
 NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
 RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
+RuntimeGeneratedFunctions = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47"
 SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
@@ -38,7 +38,6 @@ DiffEqBase = "6.48"
 DiffEqJump = "6.7.5"
 DiffRules = "0.1, 1.0"
 DocStringExtensions = "0.7, 0.8"
-GeneralizedGenerated = "0.1.4, 0.2"
 IfElse = "0.1"
 LabelledArrays = "1.3"
 Latexify = "0.11, 0.12, 0.13, 0.14"
@@ -47,6 +46,7 @@ MacroTools = "0.5"
 NaNMath = "0.3"
 RecursiveArrayTools = "2.3"
 Requires = "1.0"
+RuntimeGeneratedFunctions = "0.4"
 SafeTestsets = "0.0.1"
 SpecialFunctions = "0.7, 0.8, 0.9, 0.10"
 StaticArrays = "0.10, 0.11, 0.12"

src/ModelingToolkit.jl

@@ -8,14 +8,16 @@ using UnPack: @unpack
 using DiffEqJump
 using DataStructures: OrderedDict, OrderedSet
 using SpecialFunctions, NaNMath
+using RuntimeGeneratedFunctions
 using Base.Threads
 import MacroTools: splitdef, combinedef, postwalk, striplines
-import GeneralizedGenerated
 import Libdl
 using DocStringExtensions
 using Base: RefValue
 import IfElse
 
+RuntimeGeneratedFunctions.init(@__MODULE__)
+
 using RecursiveArrayTools
 
 import SymbolicUtils

src/build_function.jl

@@ -130,19 +130,7 @@ function _build_function(target::JuliaTarget, op::Operation, args...;
 end
 
 function _build_and_inject_function(mod::Module, ex)
-    # Generate the function, which will process the expression
-    runtimefn = GeneralizedGenerated.mk_function(mod, ex)
-
-    # Extract the processed expression of the function body
-    params = typeof(runtimefn).parameters
-    fn_expr = GeneralizedGenerated.NGG.from_type(params[3])
-
-    # Inject our externally registered module functions
-    new_expr = ModelingToolkit.inject_registered_module_functions(fn_expr)
-
-    # Reconstruct the RuntimeFn's Body
-    new_body = GeneralizedGenerated.NGG.to_type(new_expr)
-    return GeneralizedGenerated.RuntimeFn{params[1:2]..., new_body, params[4]}()
+	@RuntimeGeneratedFunction(ModelingToolkit.inject_registered_module_functions(ex))
 end
 
 # Detect heterogeneous element types of "arrays of matrices/sparce matrices"
@@ -186,7 +174,7 @@ function _build_function(target::JuliaTarget, rhss, args...;
 
 Generates a Julia function which can then be utilized for further evaluations.
 If expression=Val{false}, the return is a Julia function which utilizes
-GeneralizedGenerated.jl in order to be free of world-age issues.
+RuntimeGeneratedFunctions.jl in order to be free of world-age issues.
 
 If the `Expression` is an `Operation`, the generated function is a function
 with a scalar output, otherwise if it's an `AbstractArray{Operation}`, the output
@@ -550,7 +538,7 @@ function _build_function(target::CTarget, eqs::Array{<:Equation}, args...;
 		open(`gcc -fPIC -O3 -msse3 -xc -shared -o $(libpath * "." * Libdl.dlext) -`, "w") do f
 			print(f, ex)
 		end
-		eval(:((du::Array{Float64},u::Array{Float64},p::Array{Float64},t::Float64) -> ccall(("diffeqf", $libpath), Cvoid, (Ptr{Float64}, Ptr{Float64}, Ptr{Float64}, Float64), du, u, p, t)))
+		@RuntimeGeneratedFunction(:((du::Array{Float64},u::Array{Float64},p::Array{Float64},t::Float64) -> ccall(("diffeqf", $libpath), Cvoid, (Ptr{Float64}, Ptr{Float64}, Ptr{Float64}, Float64), du, u, p, t)))
 	end
 end
 

src/systems/control/controlsystem.jl

@@ -131,8 +131,8 @@ function runge_kutta_discretize(sys::ControlSystem,dt,tspan;
     n = length(tspan[1]:dt:tspan[2]) - 1
     m = length(tab.α)
 
-    f = eval(build_function([x.rhs for x in equations(sys)],sys.states,sys.controls,sys.ps,sys.iv,conv = ModelingToolkit.ControlToExpr(sys))[1])
-    L = eval(build_function(sys.loss,sys.states,sys.controls,sys.ps,sys.iv,conv = ModelingToolkit.ControlToExpr(sys)))
+    f = @RuntimeGeneratedFunction(build_function([x.rhs for x in equations(sys)],sys.states,sys.controls,sys.ps,sys.iv,conv = ModelingToolkit.ControlToExpr(sys))[1])
+    L = @RuntimeGeneratedFunction(build_function(sys.loss,sys.states,sys.controls,sys.ps,sys.iv,conv = ModelingToolkit.ControlToExpr(sys)))
 
     # Expand out all of the variables in time and by stages
     timed_vars = [[Variable(x.name,i)(sys.iv()) for i in 1:n+1] for x in states(sys)]

src/systems/diffeqs/abstractodesystem.jl

@@ -119,15 +119,15 @@ function DiffEqBase.ODEFunction{iip}(sys::AbstractODESystem, dvs = states(sys),
                                      kwargs...) where {iip}
 
     f_gen = generate_function(sys, dvs, ps; expression=Val{eval_expression}, kwargs...)
-    f_oop,f_iip = eval_expression ? ModelingToolkit.eval.(f_gen) : f_gen
+    f_oop,f_iip = eval_expression ? (@RuntimeGeneratedFunction(ex) for ex in f_gen) : f_gen
     f(u,p,t) = f_oop(u,p,t)
     f(du,u,p,t) = f_iip(du,u,p,t)
 
     if tgrad
         tgrad_gen = generate_tgrad(sys, dvs, ps;
                                    simplify=simplify,
                                    expression=Val{eval_expression}, kwargs...)
-        tgrad_oop,tgrad_iip = eval_expression ? ModelingToolkit.eval.(tgrad_gen) : tgrad_gen
+        tgrad_oop,tgrad_iip = eval_expression ? (@RuntimeGeneratedFunction(ex) for ex in tgrad_gen) : tgrad_gen
         _tgrad(u,p,t) = tgrad_oop(u,p,t)
         _tgrad(J,u,p,t) = tgrad_iip(J,u,p,t)
     else
@@ -138,7 +138,7 @@ function DiffEqBase.ODEFunction{iip}(sys::AbstractODESystem, dvs = states(sys),
         jac_gen = generate_jacobian(sys, dvs, ps;
                                     simplify=simplify, sparse = sparse,
                                     expression=Val{eval_expression}, kwargs...)
-        jac_oop,jac_iip = eval_expression ? ModelingToolkit.eval.(jac_gen) : jac_gen
+        jac_oop,jac_iip = eval_expression ? (@RuntimeGeneratedFunction(ex) for ex in jac_gen) : jac_gen
         _jac(u,p,t) = jac_oop(u,p,t)
         _jac(J,u,p,t) = jac_iip(J,u,p,t)
     else
@@ -149,12 +149,12 @@ function DiffEqBase.ODEFunction{iip}(sys::AbstractODESystem, dvs = states(sys),
 
     _M = (u0 === nothing || M == I) ? M : ArrayInterface.restructure(u0 .* u0',M)
 
-    ODEFunction{iip}(DiffEqBase.EvalFunc(f),
-                      jac = _jac === nothing ? nothing : DiffEqBase.EvalFunc(_jac),
-                      tgrad = _tgrad === nothing ? nothing : DiffEqBase.EvalFunc(_tgrad),
-                      mass_matrix = _M,
-                      jac_prototype = sparse ? similar(sys.jac[],Float64) : nothing,
-                      syms = Symbol.(states(sys)))
+    ODEFunction{iip}(f,
+                     jac = _jac === nothing ? nothing : _jac,
+                     tgrad = _tgrad === nothing ? nothing : _tgrad,
+                     mass_matrix = _M,
+                     jac_prototype = sparse ? similar(sys.jac[],Float64) : nothing,
+                     syms = Symbol.(states(sys)))
 end
 
 """

src/systems/diffeqs/sdesystem.jl

@@ -150,9 +150,9 @@ function DiffEqBase.SDEFunction{iip}(sys::SDESystem, dvs = sys.states, ps = sys.
                                      version = nothing, tgrad=false, sparse = false,
                                      jac = false, Wfact = false, eval_expression = true, kwargs...) where {iip}
     f_gen = generate_function(sys, dvs, ps; expression=Val{eval_expression}, kwargs...)
-    f_oop,f_iip = eval_expression ? ModelingToolkit.eval.(f_gen) : f_gen
+    f_oop,f_iip = eval_expression ? (@RuntimeGeneratedFunction(ex) for ex in f_gen) : f_gen
     g_gen = generate_diffusion_function(sys, dvs, ps; expression=Val{eval_expression}, kwargs...)
-    g_oop,g_iip = eval_expression ? ModelingToolkit.eval.(g_gen) : g_gen
+    g_oop,g_iip = eval_expression ? (@RuntimeGeneratedFunction(ex) for ex in g_gen) : g_gen
 
     f(u,p,t) = f_oop(u,p,t)
     f(du,u,p,t) = f_iip(du,u,p,t)
@@ -161,7 +161,7 @@ function DiffEqBase.SDEFunction{iip}(sys::SDESystem, dvs = sys.states, ps = sys.
 
     if tgrad
         tgrad_gen = generate_tgrad(sys, dvs, ps; expression=Val{eval_expression}, kwargs...)
-        tgrad_oop,tgrad_iip = eval_expression ? ModelingToolkit.eval.(tgrad_gen) : tgrad_gen
+        tgrad_oop,tgrad_iip = eval_expression ? (@RuntimeGeneratedFunction(ex) for ex in tgrad_gen) : tgrad_gen
         _tgrad(u,p,t) = tgrad_oop(u,p,t)
         _tgrad(J,u,p,t) = tgrad_iip(J,u,p,t)
     else
@@ -170,7 +170,7 @@ function DiffEqBase.SDEFunction{iip}(sys::SDESystem, dvs = sys.states, ps = sys.
 
     if jac
         jac_gen = generate_jacobian(sys, dvs, ps; expression=Val{eval_expression}, sparse=sparse, kwargs...)
-        jac_oop,jac_iip = eval_expression ? ModelingToolkit.eval.(jac_gen) : jac_gen
+        jac_oop,jac_iip = eval_expression ? (@RuntimeGeneratedFunction(ex) for ex in jac_gen) : jac_gen
         _jac(u,p,t) = jac_oop(u,p,t)
         _jac(J,u,p,t) = jac_iip(J,u,p,t)
     else
@@ -179,8 +179,8 @@ function DiffEqBase.SDEFunction{iip}(sys::SDESystem, dvs = sys.states, ps = sys.
 
     if Wfact
         tmp_Wfact,tmp_Wfact_t = generate_factorized_W(sys, dvs, ps, true; expression=Val{true}, kwargs...)
-        Wfact_oop, Wfact_iip = eval_expression ? ModelingToolkit.eval.(tmp_Wfact) : tmp_Wfact
-        Wfact_oop_t, Wfact_iip_t = eval_expression ? ModelingToolkit.eval.(tmp_Wfact_t) : tmp_Wfact_t
+        Wfact_oop, Wfact_iip = eval_expression ? (@RuntimeGeneratedFunction(ex) for ex in tmp_Wfact) : tmp_Wfact
+        Wfact_oop_t, Wfact_iip_t = eval_expression ? (@RuntimeGeneratedFunction(ex) for ex in tmp_Wfact_t) : tmp_Wfact_t
         _Wfact(u,p,dtgamma,t) = Wfact_oop(u,p,dtgamma,t)
         _Wfact(W,u,p,dtgamma,t) = Wfact_iip(W,u,p,dtgamma,t)
         _Wfact_t(u,p,dtgamma,t) = Wfact_oop_t(u,p,dtgamma,t)
@@ -192,13 +192,13 @@ function DiffEqBase.SDEFunction{iip}(sys::SDESystem, dvs = sys.states, ps = sys.
     M = calculate_massmatrix(sys)
     _M = (u0 === nothing || M == I) ? M : ArrayInterface.restructure(u0 .* u0',M)
 
-    SDEFunction{iip}(DiffEqBase.EvalFunc(f),DiffEqBase.EvalFunc(g),
-                      jac = _jac === nothing ? nothing : DiffEqBase.EvalFunc(_jac),
-                      tgrad = _tgrad === nothing ? nothing : DiffEqBase.EvalFunc(_tgrad),
-                      Wfact = _Wfact === nothing ? nothing : DiffEqBase.EvalFunc(_Wfact),
-                      Wfact_t = _Wfact_t === nothing ? nothing : DiffEqBase.EvalFunc(_Wfact_t),
-                      mass_matrix = _M,
-                      syms = Symbol.(sys.states))
+    SDEFunction{iip}(f,g,
+                     jac = _jac === nothing ? nothing : _jac,
+                     tgrad = _tgrad === nothing ? nothing : _tgrad,
+                     Wfact = _Wfact === nothing ? nothing : _Wfact,
+                     Wfact_t = _Wfact_t === nothing ? nothing : _Wfact_t,
+                     mass_matrix = _M,
+                     syms = Symbol.(sys.states))
 end
 
 function DiffEqBase.SDEFunction(sys::SDESystem, args...; kwargs...)

src/systems/jumps/jumpsystem.jl

@@ -79,10 +79,10 @@ generate_affect_function(js, affect, outputidxs) = build_function(affect, states
                                                       outputidxs=outputidxs)[2]
 
 function assemble_vrj(js, vrj, statetoid)
-    rate   = eval(generate_rate_function(js, vrj.rate))
+    rate   = @RuntimeGeneratedFunction(generate_rate_function(js, vrj.rate))
     outputvars = (convert(Variable,affect.lhs) for affect in vrj.affect!)
     outputidxs = ((statetoid[var] for var in outputvars)...,)
-    affect = eval(generate_affect_function(js, vrj.affect!, outputidxs))
+    affect = @RuntimeGeneratedFunction(generate_affect_function(js, vrj.affect!, outputidxs))
     VariableRateJump(rate, affect)
 end
 
@@ -99,10 +99,10 @@ function assemble_vrj_expr(js, vrj, statetoid)
 end
 
 function assemble_crj(js, crj, statetoid)
-    rate   = eval(generate_rate_function(js, crj.rate))
+    rate   = @RuntimeGeneratedFunction(generate_rate_function(js, crj.rate))
     outputvars = (convert(Variable,affect.lhs) for affect in crj.affect!)
     outputidxs = ((statetoid[var] for var in outputvars)...,)
-    affect = eval(generate_affect_function(js, crj.affect!, outputidxs))
+    affect = @RuntimeGeneratedFunction(generate_affect_function(js, crj.affect!, outputidxs))
     ConstantRateJump(rate, affect)
 end
 
@@ -201,8 +201,7 @@ function DiffEqBase.DiscreteProblem(sys::JumpSystem, u0map, tspan::Tuple,
     else
         p = parammap
     end
-    # EvalFunc because we know that the jump functions are generated via eval
-    f  = DiffEqBase.EvalFunc(DiffEqBase.DISCRETE_INPLACE_DEFAULT)
+    f  = DiffEqBase.DISCRETE_INPLACE_DEFAULT
     df = DiscreteFunction(f, syms=Symbol.(states(sys)))
     DiscreteProblem(df, u0, tspan, p; kwargs...)
 end
@@ -231,9 +230,8 @@ function DiscreteProblemExpr(sys::JumpSystem, u0map, tspan::Tuple,
     u0 = varmap_to_vars(u0map, states(sys))
     p  = varmap_to_vars(parammap, parameters(sys))
     # identity function to make syms works
-    # EvalFunc because we know that the jump functions are generated via eval
     quote
-        f  = DiffEqBase.EvalFunc(DiffEqBase.DISCRETE_INPLACE_DEFAULT)
+        f  = DiffEqBase.DISCRETE_INPLACE_DEFAULT
         u0 = $u0
         p = $p
         tspan = $tspan
@@ -287,7 +285,7 @@ end
 
 
 ### Functions to determine which states a jump depends on
-function get_variables!(dep, jump::Union{ConstantRateJump,VariableRateJump}, variables) 
+function get_variables!(dep, jump::Union{ConstantRateJump,VariableRateJump}, variables)
     (jump.rate isa Operation) && get_variables!(dep, jump.rate, variables)
     dep
 end