Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.soft-sys.math.mathematica > #5268
| 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> |
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
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