       Re: Compilation: Avoiding inlining

• To: mathgroup at smc.vnet.net
• Subject: [mg121558] Re: Compilation: Avoiding inlining
• From: Oliver Ruebenkoenig <ruebenko at wolfram.com>
• Date: Mon, 19 Sep 2011 07:07:49 -0400 (EDT)
• Delivered-to: l-mathgroup@mail-archive0.wolfram.com
• References: <201109171027.GAA26060@smc.vnet.net>

```On Sat, 17 Sep 2011, DmitryG wrote:

> Hi Oliver,
>
> thank you for your response! I am interested now in the systems of
> equations that are non-vectorizable. By mistake, in my first post I
> have used a system of equations that can be vectorized and this turned
> the discussion away from the topic. But in my second post, I have a
> non-vectorizable system of equations.
>
> I have identified three ways to define the system of equations. Below
> are the results with Mathematica compilation.
>
> 1)
> (* Definition of the equations *)
> NN = 1000;
> F = Function[{t, x}, Table[ -x[[i]] Sin[0.1 t]^2/(1 +100 Sum[x[[i +
> j]], {j, 1, Min[3, NN - i]}]^2), {i, 1, NN}]];
>
>>> Evaluation time 24.4983979 - slow execution.   No inlining. Compiled code 189 lines independently of NN. Compilation in C gives practically the same speed
>
> 2)
> (* Definition of the equations *)
> NN = 1000;
> F = Function[{t, x}, Table[ Unevaluated[-x[[i]] Sin[0.1 t]^2/(1 +100
> Sum[x[[i + j]], {j, 1, Min[3, NN - i]}]^2)], {i, 1, NN}]];
>
>>> Evaluation time 4.7582721.   No inlining. Compiled code 93 lines independently of NN.  Compilation in C gives practically the same speed
>
> 3)
> (* Definition of the equations *)
> NN = 1000;
> F = Function[{t, x}, Evaluate[Table[ -x[[i]] Sin[0.1 t]^2/(1 +100
> Sum[x[[i + j]], {j, 1, Min[3, NN - i]}]^2), {i, 1, NN}]]];
>
>>> Evaluation time 1.0680555 - fastest execution.   Here we have inlining of the code, the size of the compiled code increases with NN. Compilation in C is impossible.
>
>
> One can see that there are many different ways with very different
> results, and it is very important to find the best one - more
> important than to buy a faster computer;-))
>
> Does in make sense to introduce F as a compiled function, as you have
> done in your response? We already make compilation of the RK-4
> procedure with F injected into it.
>
> Best,
>
> Dmitry
>
>

Dmitry,

here is a version that, I hope, is a little less trick to understand:

ClearAll[makeCompRK]
makeCompRK[f_] :=
Compile[{{x0, _Real, 1}, {t0, _Real}, {tMax, _Real}, {n, _Integer}},
Module[{h, K1, K2, K3, K4, SolList, x = x0, t}, h = (tMax - t0)/n;
SolList = Table[x0, {n + 1}];
Do[t = t0 + k h;
K1 = h f[t, x];
K2 = h f[t + (1/2) h, x + (1/2) K1];
K3 = h f[t + (1/2) h, x + (1/2) K2];
K4 = h f[t + h, x + K3];
x = x + (1/6) K1 + (1/3) K2 + (1/3) K3 + (1/6) K4;
SolList[[k + 1]] = x, {k, 1, n}];
SolList](*,CompilationTarget->"C"*)
,
CompilationOptions -> {"InlineCompiledFunctions" -> True}]

Concerning the function:

NN = 1000;

cRHS = With[{NN = NN},
Compile[{{t, _Real, 0}, {x, _Real, 1}}, -x*
Sin[0.1 t]^2/
Table[(1 + 100 Sum[x[[i + j]], {j, 1, Min[3, NN - i]}]^2), {i,
1, NN}](*,CompilationTarget->"C"*)]];

Needs["CompiledFunctionTools`"]
(*CompilePrint[cRHS]*)

(*Compilation*)
tt0 = AbsoluteTime[];
Timing[RK4Comp2 = makeCompRK[cRHS];]
AbsoluteTime[] - tt0

(* CompilePrint[RK4Comp2] *)
(* switch inling to True/False to see what is happening *)

(*Setting parameters and Calculation*)x0 =
Table[RandomReal[{0, 1}], {i, 1, NN}]; t0 = 0; tMax = 100; n = 500;

tt0 = AbsoluteTime[];
Sol2 = RK4Comp2[x0, t0, tMax, n];
AbsoluteTime[] - tt0

on my computer. The .. -> "C" version about needs about 0.12s on my
computer.

Hope this helps,

Oliver

```

• Prev by Date: Re: Compilation: Avoiding inlining
• Next by Date: Re: Texture in version 8, fine, but don't export...?
• Previous by thread: Re: Compilation: Avoiding inlining
• Next by thread: Re: Compilation: Avoiding inlining