Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.soft-sys.math.mathematica > #5268

Re: ParallelDo and C-compiled routines

From "Oleksandr Rasputinov" <oleksandr_rasputinov@hmamail.com>
Newsgroups comp.soft-sys.math.mathematica
Subject Re: ParallelDo and C-compiled routines
Date 2011-09-29 06:05 +0000
Organization Steven M. Christensen and Associates, Inc and MathTensor, Inc.
Message-ID <j611s1$lva$1@smc.vnet.net> (permalink)
References <j5ug1a$7r5$1@smc.vnet.net>

Show all headers | View raw


On Wed, 28 Sep 2011 07:49:14 +0100, DmitryG <einschlag@gmail.com> wrote:

> Hi All,
>
> I am going to run several instances of a long calculation on different
> cores of my computer and then average the results. The program looks
> like this:
>
> SetSharedVariable[Res];
> ParallelDo[
>  Res[[iKer]] = LongRoutine;
>  , {iKer, 1, NKer}]
>
>  LongRoutine is compiled. When compiled in C, it is two times faster
> than when compiled in Mathematica. In the case of a Do cycle, this
> speed difference can be seen, However, in the case of ParallelDo I
> have the speed of the Mathematica-compiled routine independently of
> the CompilationTarget in LongRoutine, even if I set NKer=1.
>
> What does it mean? Are routines compiled in C unable of parallel
> computing? Or there is a magic option to make them work? I tried
> Parallelization->True but there is no result, and it seems this option
> is for applying the routine to lists.
>
> Here is an example:
> ************************************************************
> NKer = 1;
>
> (* Subroutine compiled in Mathematica *)
> m = Compile[ {{x, _Real}, {n, _Integer}},
>    	Module[ {sum, inc}, sum = 1.0; inc = 1.0;
>     Do[inc = inc*x/i; sum = sum + inc, {i, n}]; sum]];
>
> (* Subroutine compiled in C *)
> c = Compile[ {{x, _Real}, {n, _Integer}},
>    	Module[ {sum, inc}, sum = 1.0; inc = 1.0;
>     Do[inc = inc*x/i; sum = sum + inc, {i, n}]; sum],
>    CompilationTarget -> "C"];
>
> (* There is a difference between Mathematica and C *)
> Do[
>  Print[AbsoluteTiming[m[1.5, 10000000]][[1]]];
>  Print[AbsoluteTiming[c[1.5, 10000000]][[1]]];
>  , {iKer, 1, NKer}]
> Print[];
>
> (* With ParallelDo there is no difference *)
> ParallelDo[
>  Print[AbsoluteTiming[m[1.5, 10000000]][[1]]];
>  Print[AbsoluteTiming[c[1.5, 10000000]][[1]]];
>  , {iKer, 1, NKer}]
> **************************************************************
>
> Any help?
>
> Best,
>
> Dmitry
>

The behaviour you observe here is quite subtle in several respects.  
Ordinarily, one might expect to have to call DistributeDefinitions[m, c]  
to replicate the definitions of m and c in the subkernel(s) before making  
a parallel evaluation, otherwise the argument sent to each subkernel would  
be returned unchanged to be evaluated on the master kernel when the result  
is built. In this case, however, the message printed by the subkernel  
indicates that the evaluation is not in fact being performed in the master  
kernel. (If it was, you would have seen a difference in run-time between  
the two compiled functions.) This caught me a little by surprise at first,  
since unlike in the Parallel Computing Toolkit, definitions are now  
distributed automatically by the internal function parallelIterate (on top  
of which ParallelDo is built). At any rate, although ParallelDo succeeds  
in defining m and c in the subkernels, it appears that CompiledFunctions  
referencing LibraryFunctions are stateful, in that they depend on the  
LibraryFunction containing the compiled code having already been loaded.  
If not, they fall back to evaluation in the Mathematica virtual machine,  
which explains why c performs the same as m in this case.

To solve the problem, you must either compile c separately in each  
subkernel by wrapping its definition in ParallelEvaluate, or, preferably,  
load the LibraryFunction manually and update the definition of c  
accordingly. To do the latter, you can use

ParallelDo[
  Print[AbsoluteTiming[m[1.5, 10000000]][[1]]];
  c[[-1]] = LibraryFunctionLoad @@ c[[-1]];
  Print[AbsoluteTiming[c[1.5, 10000000]][[1]]];
  , {iKer, 1, NKer} ]

in which case you will see the expected difference in run-time.

Back to comp.soft-sys.math.mathematica | Previous | Next — Previous in thread | Next in thread | Find similar | Unroll thread


Thread

ParallelDo and C-compiled routines DmitryG <einschlag@gmail.com> - 2011-09-28 06:49 +0000
  Re: ParallelDo and C-compiled routines "Oleksandr Rasputinov" <oleksandr_rasputinov@hmamail.com> - 2011-09-29 06:05 +0000
    Re: ParallelDo and C-compiled routines DmitryG <einschlag@gmail.com> - 2011-09-30 08:07 +0000
    Re: ParallelDo and C-compiled routines "Oleksandr Rasputinov" <oleksandr_rasputinov@hmamail.com> - 2011-10-01 07:11 +0000
  Re: ParallelDo and C-compiled routines DmitryG <einschlag@gmail.com> - 2011-09-29 06:09 +0000
  Re: ParallelDo and C-compiled routines Patrick Scheibe <pscheibe@trm.uni-leipzig.de> - 2011-09-30 08:04 +0000
  Re: ParallelDo and C-compiled routines Gabriel Landi <gtlandi@gmail.com> - 2011-10-02 06:39 +0000
  Re: ParallelDo and C-compiled routines Patrick Scheibe <pscheibe@trm.uni-leipzig.de> - 2011-10-03 08:26 +0000
  Re: ParallelDo and C-compiled routines Patrick Scheibe <pscheibe@trm.uni-leipzig.de> - 2011-10-03 08:21 +0000
  Re: ParallelDo and C-compiled routines Gabriel Landi <gtlandi@gmail.com> - 2011-10-03 08:32 +0000

csiph-web