get direct c compilation working

Author: ChrisRackauckas

docs/src/build_function.md

@@ -0,0 +1 @@
+# Function Building and Compilation (build_function)

src/build_function.jl

@@ -63,6 +63,10 @@ Keyword Arguments:
       programming language
     - `MATLABTarget`: Generates an anonymous function for use in MATLAB and Octave
       environments
+- `fname`: Used by some targets for the name of the function in the target space.
+
+Note that not all build targets support the full compilation interface. Check the
+individual target documentation for details.
 """
 function build_function(args...;target = JuliaTarget(),kwargs...)
   _build_function(target,args...;kwargs...)
@@ -455,11 +459,73 @@ function numbered_expr(de::ModelingToolkit.Equation,args...;varordering = args[1
 end
 numbered_expr(c::ModelingToolkit.Constant,args...;kwargs...) = c.value
 
-function _build_function(target::StanTarget, eqs, vs, ps, iv,
-                         conv = simplified_expr, expression = Val{true};
+"""
+Build function target: CTarget
+
+```julia
+function _build_function(target::CTarget, eqs::Array{<:Equation}, args...;
+                         conv = simplified_expr, expression = Val{true},
+                         fname = :diffeqf,
+						 lhsname=:du,rhsnames=[Symbol("RHS$i") for i in 1:length(args)],
+						 libpath=tempname(),compiler=:gcc)
+```
+
+This builds an in-place C function. Only works on arrays of equations. If
+`expression == Val{false}`, then this builds a function in C, compiles it,
+and returns a lambda to that compiled function. These special keyword arguments
+control the compilation:
+
+- libpath: the path to store the binary. Defaults to a temporary path.
+- compiler: which C compiler to use. Defaults to :gcc, which is currently the
+  only available option.
+"""
+function _build_function(target::CTarget, eqs::Array{<:Equation}, args...;
+                         conv = simplified_expr, expression = Val{true},
+                         fname = :diffeqf,
+						 lhsname=:du,rhsnames=[Symbol("RHS$i") for i in 1:length(args)],
+						 libpath=tempname(),compiler=:gcc)
+    differential_equation = string(join([numbered_expr(eq,args...,lhsname=lhsname,
+                                  rhsnames=rhsnames,offset=-1) for
+                                  (i, eq) ∈ enumerate(eqs)],";\n  "),";")
+
+    argstrs = join(vcat("double* $(lhsname)",[typeof(args[i])<:Array ? "double* $(rhsnames[i])" : "double $(rhsnames[i])" for i in 1:length(args)]),", ")
+	ex = """
+    void $fname($(argstrs...)) {
+      $differential_equation
+    }
+    """
+
+	if expression == Val{true}
+		return ex
+	else
+		@assert compiler == :gcc
+		ex = build_function(eqs,args...;target=ModelingToolkit.CTarget())
+		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)))
+	end
+end
+
+"""
+Build function target: StanTarget
+
+```julia
+function _build_function(target::StanTarget, eqs::Array{<:Equation}, vs, ps, iv;
+                         conv = simplified_expr, expression = Val{true},
                          fname = :diffeqf, lhsname=:internal_var___du,
-                         varname=:internal_var___u,paramname=:internal_var___p)
-    rhsnames=[varname,paramname]
+                         rhsnames=[:internal_var___u,:internal_var___p,:internal_var___t])
+```
+
+This builds an in-place Stan function compatible with the Stan differential equation solvers.
+Unlike other build targets, this one requestions (vs, ps, iv) as the function arguments.
+Only allowed on arrays of equations.
+"""
+function _build_function(target::StanTarget, eqs::Array{<:Equation}, vs, ps, iv;
+                         conv = simplified_expr, expression = Val{true},
+                         fname = :diffeqf, lhsname=:internal_var___du,
+                         rhsnames=[:internal_var___u,:internal_var___p,:internal_var___t])
+	@assert expression == Val{true}
     differential_equation = string(join([numbered_expr(eq,vs,ps,lhsname=lhsname,
                                    rhsnames=rhsnames) for
                                    (i, eq) ∈ enumerate(eqs)],";\n  "),";")
@@ -472,26 +538,26 @@ function _build_function(target::StanTarget, eqs, vs, ps, iv,
     """
 end
 
-function _build_function(target::CTarget, eqs, vs, ps, iv;
+"""
+Build function target: MATLABTarget
+
+```julia
+function _build_function(target::MATLABTarget, eqs::Array{<:Equation}, args...;
                          conv = simplified_expr, expression = Val{true},
-                         fname = :diffeqf, derivname=:internal_var___du,
-                         varname=:internal_var___u,paramname=:internal_var___p)
-    differential_equation = string(join([numbered_expr(eq,vs,ps,lhsname=derivname,
-                                  rhsnames=[varname,paramname],offset=-1) for
-                                  (i, eq) ∈ enumerate(eqs)],";\n  "),";")
-    """
-    void $fname(double* $derivname, double* $varname, double* $paramname, double $iv) {
-      $differential_equation
-    }
-    """
-end
+                         lhsname=:internal_var___du,
+                         rhsnames=[:internal_var___u,:internal_var___p,:internal_var___t])
+```
 
-function _build_function(target::MATLABTarget, eqs, vs, ps, iv;
+This builds an out of place anonymous function @(t,rhsnames[1]) to be used in MATLAB.
+Compatible with the MATLAB differential equation solvers. Only allowed on arrays
+of equations.
+"""
+function _build_function(target::MATLABTarget, eqs::Array{<:Equation}, args...;
                          conv = simplified_expr, expression = Val{true},
-                         fname = :diffeqf, derivname=:internal_var___du,
-                         varname=:internal_var___u,paramname=:internal_var___p)
-	rhsnames=[varname,paramname]
-    matstr = join([numbered_expr(eq.rhs,vs,ps,lhsname=derivname,
+                         fname = :diffeqf, lhsname=:internal_var___du,
+                         rhsnames=[:internal_var___u,:internal_var___p,:internal_var___t])
+	@assert expression == Val{true}
+    matstr = join([numbered_expr(eq.rhs,args...,lhsname=lhsname,
                                   rhsnames=rhsnames) for
                                   (i, eq) ∈ enumerate(eqs)],"; ")
 
@@ -500,22 +566,3 @@ function _build_function(target::MATLABTarget, eqs, vs, ps, iv;
     matstr = "$fname = @(t,$(rhsnames[1])) ["*matstr*"];"
     matstr
 end
-
-"""
-compile_cfunction(eqs,args...;libpath=tempname(),compiler=:gcc)
-
-Builds a function in C, compiles it, and returns a lambda to that compiled function.
-Arguments match those of `build_function`. Keyword arguments:
-
-- libpath: the path to store the binary. Defaults to a temporary path.
-- compiler: which C compiler to use. Defaults to :gcc, which is currently the
-  only available option.
-"""
-function compile_cfunction(eqs,args...;libpath=tempname(),compiler=:gcc)
-	@assert compiler == :gcc
-    ex = build_function(eqs,args...;target=ModelingToolkit.CTarget())
-    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)))
-end

test/build_targets.jl

@@ -14,7 +14,9 @@ eqs = [D(x) ~ a*x - x*y,
     }
     """
 
-@test ModelingToolkit.build_function(eqs,[x,y],[a],t,target = ModelingToolkit.CTarget()) ==
+@test ModelingToolkit.build_function(eqs,[x,y],[a],t,target = ModelingToolkit.CTarget(),
+                                     lhsname=:internal_var___du,
+                                     rhsnames=[:internal_var___u,:internal_var___p,:t]) ==
   """
   void diffeqf(double* internal_var___du, double* internal_var___u, double* internal_var___p, double t) {
     internal_var___du[0] = internal_var___p[0] * internal_var___u[0] - internal_var___u[0] * internal_var___u[1];
@@ -28,17 +30,25 @@ eqs = [D(x) ~ a*x - x*y,
 
 sys = ODESystem(eqs,t,[x,y],[a])
 
-@test ModelingToolkit.build_function(eqs,[x,y],[a],t,target = ModelingToolkit.CTarget()) ==
-      ModelingToolkit.build_function(sys.eqs,[x,y],[a],t,target = ModelingToolkit.CTarget())
+@test ModelingToolkit.build_function(eqs,[x,y],[a],t,target = ModelingToolkit.CTarget(),
+                                     lhsname=:internal_var___du,
+                                     rhsnames=[:internal_var___u,:internal_var___p,:t]) ==
+      ModelingToolkit.build_function(sys.eqs,[x,y],[a],t,target = ModelingToolkit.CTarget(),
+                                           lhsname=:internal_var___du,
+                                           rhsnames=[:internal_var___u,:internal_var___p,:t])
 
 @test ModelingToolkit.build_function(eqs,[x,y],[a],t,target = ModelingToolkit.StanTarget()) ==
       ModelingToolkit.build_function(sys.eqs,[x,y],[a],t,target = ModelingToolkit.StanTarget())
 
 @test ModelingToolkit.build_function(eqs,[x,y],[a],t,target = ModelingToolkit.MATLABTarget()) ==
       ModelingToolkit.build_function(sys.eqs,[x,y],[a],t,target = ModelingToolkit.MATLABTarget())
 
-@test ModelingToolkit.build_function(eqs,[x,y],[a],t,target = ModelingToolkit.CTarget()) ==
-      ModelingToolkit.build_function(sys.eqs,sys.states,sys.ps,sys.iv,target = ModelingToolkit.CTarget())
+@test ModelingToolkit.build_function(eqs,[x,y],[a],t,target = ModelingToolkit.CTarget(),
+                                     lhsname=:internal_var___du,
+                                     rhsnames=[:internal_var___u,:internal_var___p,:t]) ==
+      ModelingToolkit.build_function(sys.eqs,sys.states,sys.ps,sys.iv,target = ModelingToolkit.CTarget(),
+                                     lhsname=:internal_var___du,
+                                     rhsnames=[:internal_var___u,:internal_var___p,:t])
 
 @test ModelingToolkit.build_function(eqs,[x,y],[a],t,target = ModelingToolkit.StanTarget()) ==
       ModelingToolkit.build_function(sys.eqs,sys.states,sys.ps,sys.iv,target = ModelingToolkit.StanTarget())

test/ccompile.jl

@@ -0,0 +1,15 @@
+using ModelingToolkit, Test
+@parameters t a
+@variables x y
+@derivatives D'~t
+eqs = [D(x) ~ a*x - x*y,
+       D(y) ~ -3y + x*y]
+f = build_function(eqs,[x,y],[a],t,expression=Val{false},target=ModelingToolkit.CTarget())
+f2 = eval(build_function([x.rhs for x in eqs],[x,y],[a],t)[2])
+du = rand(2); du2 = rand(2)
+u = rand(2)
+p = rand(1)
+_t = rand()
+f(du,u,p,_t)
+f2(du2,u,p,_t)
+@test du == du2

test/runtests.jl

@@ -29,3 +29,5 @@ using SafeTestsets, Test
 #@testset "Latexify recipes Test" begin include("latexify.jl") end
 @testset "Distributed Test" begin include("distributed.jl") end
 @testset "Variable Utils Test" begin include("variable_utils.jl") end
+println("Last test requires gcc available in the path!")
+@safetestset "C Compilation Test" begin include("ccompile.jl") end