[Haskell-cafe] parallelism or concurrency ? if they are different
Henk-Jan van Tuyl
hjgtuyl at chello.nl
Mon Feb 16 18:44:45 EST 2009
On Fri, 13 Feb 2009 11:09:35 +0100, Paolino <paolo.veronelli at gmail.com>
> When I came to haskell, I arrived with a small and only evolutionary
> background in programming. First monad I met was MonadState StdGen m.
> Everything was in someway acceptable, I had no problem in
> explicitating the need for the generator.
> The lesson was referential transparency. To me referential tranparency
> is still obscure as a feature.
> Not using the monad , my functions pass around a generator, then they
> are repeatable, same generator , same computation.
> Years pass by, now evolutionary algorithms need to scale multicores.
> But multicore can be used with threads or par, the difference is that
> par is pure, because it respects referential transparency. But threads
> They are always unrespectful ? Or it's an implementation issue of
> preemptive choice?
> Can I have a baton to pass around like I had for random generator, so
> that the computation ends without IO (unsafe performed) , without
> breaking tranparency,
> something like (runIOThreads :: ThreadsIO a -> ThreadsBaton -> a) ?
>> From Real World Haskell my algorithm have to be parallelized as they
> don't do some kind of IO, they don't deal with the world, but where is
> it stated that it is possible to write them with par (I couldn't) ?
> More , I'm not caring that my computation is unrepeatable, for me
> it's fine that the runtime system gives me the cached results for
> same arguments computation. The fact that it doesn't ,and recompute
> the function giving out something fuzzily different from before, is
> enough to coerce me to spit out IO values ?
> Finally, why and where the optimizer will substitute a value with its
> definition, so that it possibly get computed twice ?
I am not an expert in this matter, but as nobody answered sofar (perhaps
people were frightened off by a lack of structure in your text), I will
try to give some pointers:
- You can start a function with parameters in a thread like this
threadId <- forkIO (foo 42)
where foo has type Int -> IO ()
- Communication between threads can be done with MVars, see:
- You can find concurrency demos at:
- Links to articles about parallelism:
- To prevent recomputing, read:
Henk-Jan van Tuyl
More information about the Haskell-Cafe