Re: [Caml-list] Case study in optimization: porting a compiler from OCaml to F#

[Jean-Marc Alliot <jean-marc.alliot@irit.fr>]

We have been using Parmap and are quite happy with it (we use it as an 
alternative to the Ocaml/MPI implementation when MPI is not strictly 
required), with excellent scalability on our applications (even if we 
had to change from time to time a little bit or our code, regarding the 
fact that Parmap does not allow "in place" modifications).

Le 17/03/2013 13:06, Jon Harrop a écrit :
> What happens if the inner function returns results via mutation? I 
> assume you must rearrange the code to return all results explicitly 
> and they will then be deep copied (which destroys scalability due to 
> limited shared memory bandwidth on multicores).
As fas as I can tell there is no "copy" of any form. Parmap only 
collects results. If you do "in place" modifications, they are lost. 
Parmap is, in a way, "functional"...
> Does it do load balancing? I assume not given that ncores is hardcoded. 
There is an optional argument (chunksize) to manually control load 
balancing.
> Does a parmap with ncores=4 inside a parmap with ncores=4 create 16 
> processes? Does it deep copy inputs and/or outputs? 
Regarding outputs, Parmap uses a shared memory area and 
Marshal/Unmarshal to collect outputs. There is an optimization done when 
array of floats are returned, as marshalling is not used, thus reducing 
the overhead.
> I assume so, at least for outputs, because you cannot write results 
> in-place without a shared mutable heap. Does parmap have a large 
> constant overhead? I assume so if it is forking processes. 
Well, it depends on what you call "large constant overhead". Forking is 
not a so expensive primitive on modern Unix systems, because pages are 
only copied when written-to (copy-on-write).
> Another solution is to prefork and explicitly communicate all inputs 
> using message passing but this is equally problematic. You have to 
> rearrange the code. Deep copying inputs also destroys scalability. 
> Cheers, Jon. 

There is an article describing the implementation (I think it is also 
available online):

A “minimal disruption” skeleton experiment: seamless map & reduce 
embedding in OCaml
M. Danelutto, R. Di Cosmo
Procedia Computer Science 9 ( 2012 ) 1837 – 1846