Mathematica 9 is now available
Services & Resources / Wolfram Forums / MathGroup Archive
-----

MathGroup Archive 2011

[Date Index] [Thread Index] [Author Index]

Search the Archive

Re: Compilation options question

  • To: mathgroup at smc.vnet.net
  • Subject: [mg115832] Re: Compilation options question
  • From: Daniel Lichtblau <danl at wolfram.com>
  • Date: Sat, 22 Jan 2011 03:21:27 -0500 (EST)

Ramiro wrote:
> Hello,
> 
> I have successfully compiled the main parts of my program and runs
> much faster than before.  I do have a question.  Consider the
> following 4 examples, all compiled programs but with different
> options. Example0 is just plain compile, example1 has what I thought
> would be the optimal: parallelization and compilationtarget->"C" and
> declaration of the return types for the external calls, but it takes
> twice as long!!!  Why is that?
> 
> If I remove the declaration of the return types it goes a bit faster
> than plain Compile even though it has parallelization and
> CompilationTarget-> "C", and if I remove  CompilationTarget-> "C" it's
> about the same.
> 
> Any insight? Thanks so much to everyone for their help with Compile,
> my MCMC simulations will be much faster now.
> 
> Ramiro
> 
> p.s. My main program is basically multiplying the function in question
> (exampleN) many many times, that's why I put multiply over the same
> call.
> 
> 
> 
> In[170]:=
> example0 =
>   Compile[{{n, _Real, 1}, {a, _Real}, {b, _Real}, {t, _Real, 1}},
>    With[{tn = Total[n]},
>     b^a*Exp[LogGamma[
>         tn + a] - (Total[LogGamma[n + 1]] + LogGamma[a]) +
>        Total[n*Log[t]] - (tn + a)*Log[Total[t] + b]]]];
> Times @@ Table[
>    example0[{1, 1, 1, 1}, 1, 1, {3, 3, 3, 3}], {i,
>     10000}] // AbsoluteTiming
> 
> Out[171]= {0.210959, 6.2372127891421*10^-22811}
> 
> In[172]:=
> example1 =
>   Compile[{{n, _Real, 1}, {a, _Real}, {b, _Real}, {t, _Real, 1}},
>    With[{tn = Total[n]},
>     b^a*Exp[LogGamma[
>         tn + a] - (Total[LogGamma[n + 1]] + LogGamma[a]) +
>        Total[n*Log[t]] - (tn + a)*
>         Log[Total[t] +
>           b]]], {{LogGamma[_], _Real}, {Total[_], _Real}},
>    Parallelization -> True, CompilationTarget -> "C"];
> Times @@ Table[
>    example1[{1, 1, 1, 1}, 1, 1, {3, 3, 3, 3}], {i,
>     10000}] // AbsoluteTiming
> 
> Out[173]= {0.414509, 6.2372127890803*10^-22811}
> 
> In[174]:=
> example2 =
>   Compile[{{n, _Real, 1}, {a, _Real}, {b, _Real}, {t, _Real, 1}},
>    With[{tn = Total[n]},
>     b^a*Exp[LogGamma[
>         tn + a] - (Total[LogGamma[n + 1]] + LogGamma[a]) +
>        Total[n*Log[t]] - (tn + a)*Log[Total[t] + b]]],
>    Parallelization -> True, CompilationTarget -> "C"];
> Times @@ Table[
>    example2[{1, 1, 1, 1}, 1, 1, {3, 3, 3, 3}], {i,
>     10000}] // AbsoluteTiming
> 
> Out[175]= {0.188601, 6.2372127890803*10^-22811}
> 
> In[176]:=
> calculatePoissonsGamma =
>   Compile[{{n, _Real, 1}, {a, _Real}, {b, _Real}, {t, _Real, 1}},
>    With[{tn = Total[n]},
>     b^a*Exp[LogGamma[
>         tn + a] - (Total[LogGamma[n + 1]] + LogGamma[a]) +
>        Total[n*Log[t]] - (tn + a)*Log[Total[t] + b]]],
>    Parallelization -> True];
> Times @@ Table[
>    calculatePoissonsGamma[{1, 1, 1, 1}, 1, 1, {3, 3, 3, 3}], {i,
>     10000}] // AbsoluteTiming
> 
> Out[177]= {0.219753, 6.2372127891421*10^-22811}

You are calling the Mathematica evaluator for the LogGamma evaluations. 
I would think this call+return is slower when coming from a dll than 
when coming from the virtual byte machine (the interpreter for vanilla 
Compile).

I believe this need for evaluator calls for LogGamma (and Gamma) will be 
addressed in a future release.

As for the parallelization not helping, I suspect the issue there is 
communication speed. If without parallelization you can do 10^4 
computations in 0.22 seconds or so, then that gives an idea of haw fast 
the processor intercommunication must be in order for parallelizing to 
be useful (it must be significantly less than 2*10^(-5) seconds, that 
is). While I am no expert, it strikes me that communication speed might 
not be quite that fast. Hence the worsened rather than improved overall 
speed. I should emphasize that this is just a guess on my part.

Daniel Lichtblau
Wolfram Research


  • Prev by Date: a bug in Mathematica 7.0?
  • Next by Date: Wavelet and histogram
  • Previous by thread: Compilation options question
  • Next by thread: Re: Compilation options question