Parallel concurrent ML

Abstract

Concurrent ML (CML) is a high-level message-passing language that supports the construction of first-class synchronous abstractions called events. This mechanism has proven quite effective over the years and has been incorporated in a number of other languages. While CML provides a concurrent programming model, its implementation has always been limited to uniprocessors. This limitation is exploited in the implementation of the synchronization protocol that underlies the event mechanism, but with the advent of cheap parallel processing on the desktop (and laptop), it is time for Parallel CML.Parallel implementations of CML-like primitives for Java and Haskell exist, but build on high-level synchronization constructs that are unlikely to perform well. This paper presents a novel, parallel implementation of CML that exploits a purpose-built optimistic concurrency protocol designed for both correctness and performance on shared-memory multiprocessors. This work extends and completes an earlier protocol that supported just a strict subset of CML with synchronization on input, but not output events. Our main contributions are a model-checked reference implementation of the protocol and two concrete implementations. This paper focuses on Manticore's functional, continuation-based implementation but briefly discusses an independent, thread-based implementation written in C# and running on Microsoft's stock, parallel runtime. Although very different in detail, both derive from the same design. Experimental evaluation of the Manticore implementation reveals good performance, dispite the extra overhead of multiprocessor synchronization.

Scalable join patterns

“…Sending a message ensuring that only one thread will succeed in claiming a given message. If at any point we fail to claim a message, we roll back all of the messages claimed so far (lines [23][24]. The implementation ensures that the Chans arrays for each chord are ordered consistently, so that in any race at least one thread entering the second phase will complete the phase successfully ( §5).…”

“…Our algorithm draws some inspiration from Reppy, Russo and Xiao's PARALLEL CML, a combinator library for firstclass synchronous events [23]. The difficulty in implementing CML is, in a sense, dual to that of the join calculus: disjunctions of events (rather than conjunctions of messages) must be atomically resolved.…”

Parallel computing with the Pi-calculus

“…In our implementations we adopt a simple pessimistic locking approach because the transactions are very lightweight: there are in general no more than a dozen branches to test, and the locks must be only retained during the polling phase. A more optimistic approach, along the line of [17] could be also experimented.…”

“…In fact the combinators for synchronization events supported by CML makes it even more expressive: it is for example possible to encode dynamic choices with the possibility to insert/remove execution branches at runtime. A parallel interpretation of the core CML constructs is presented in [17]. The basic input/output events are quite similar to the π-threads commitments and the optimistic polling phase approach of [17] would probably translate to our setting without major difficulties.…”

“…A parallel interpretation of the core CML constructs is presented in [17]. The basic input/output events are quite similar to the π-threads commitments and the optimistic polling phase approach of [17] would probably translate to our setting without major difficulties. One advantage of the pessimistic protocol we adopt is that choices can be immediately resolved during the polling phase, without having to gather all the potentially active branches.…”