What functional language implementations allow threads to run in parallel?

Question

The OCaml GC imposes a global lock that prevents mutators (threads) from running in parallel although they can run concurrently (interleaved). I believe the same is true of SML/NJ and MLton but not PolyML, GHC, F#, Clojure and Scala.

What other functional language implementations allow threads to run in parallel?

Answer 1

Haskell supports parallel threads via Data Parallel Haskell

Answer 2

I'm happy to tell you that you're right and that F#, being based on the CLR, doesn't suffer from that limitation at all, and instead benefits from multithreading specific features including async workflows, the mailboxprocessor, and the wonderful upcoming (.NET 4.0) Task Parallel Library.

Answer 3

Scala and Clojure are both running on the JVM, which allows real concurrency without any single point of contention bottlenecks.

Answer 4

In addition to Haskell, you can run processes concurrently in Erlang (Concurrency-Oriented Programming) and you can also do so in F# using .NET Parallel Extensions and Asynchronous Workflows.

Answer 5

Erlang implements its own processes and process schedule and allows thousands, tens of thousands and even millions of Erlang processes (inside a single Operating System process).

In SMP and multi-core machines the Erlang Virtual Machine will allocate as many OS threads and OS processes to its process scheduler and process queue to maximise its use of underlying concurrent operations in the hardware architecture.

The concurrency paradigm exposed to the applications remains the same, of course.

Answer 6

There are a number of good implementations out there. At the moment, the Haskell people seem to be getting the best results (see ICFP 2009 paper by Simon Marlow and others as well as Haskell Symposium 2009 paper by Donnie Jones and others). Erlang is quite close behind, especially if you want to go distributed.

In six to twelve months the answers may have changed :-)

Answer 7

python is not a particularly functional language, and with the GIL, it's not very parallel, either, but combined with the multiprocessing module (standard since 2.6), you get both, but it's not quite as elegant as pure functional languages.

Brief example:

from multiprocessing import Pool

def f(x):
    return x*x

if __name__ == '__main__':
    pool = Pool(processes=4)              # start 4 worker processes
    result = pool.apply_async(f, [10])     # evaluate "f(10)" asynchronously
    print result.get(timeout=1)           # prints "100" unless your computer is *very* slow
    print pool.map(f, range(10))          # prints "[0, 1, 4,..., 81]"