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.

Java 1 has emerged as a dominant language that could eventually replace C++. It is believed that using Java would boost programmer productivity because of its well-thought design, independence from backward-compatibility with C, absence of arbitrary pointers, etc. We present the design and implementation of a parallel extension to Java. The parallel extension provides dynamic creation of remote objects with load balancing, and object groups. The language constructs are based on those of Charm++[1]. The parallel Java extension is implemented using the Converse[2] interoperability framework, which makes it possible to integrate parallel libraries written in Java with modules in other parallel languages in a single application. Keywords: parallel, message-driven programming, object-oriented, Java 1 Introduction Java, as a programming language, has seen phenomenal growth in the past few years. The initial appeal of Java was related to its connection to the Web. However, its benefits a...

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. We are pursuing such an implementation as part of the Manticore project. In this paper, we describe a parallel implementation of Asymmetric CML (ACML), which is a subset of CML that does not support output guards. We describe an optimistic concurrency protocol for implementing CML synchronization. This protocol has been implemented as part of the Manticore system. 1

Message-passing systems are typically used to achieve high-performance parallel computing. In this paper we examine how advanced concurrent programming can be achieved using existing message-passing systems. In particular, we look at Reppy's extension to Hoare's basic CSP model, called higher-order concurrency, where communication events (such as send, receive and non-deterministic choice) are first-class just like normal program variables (e.g., integers), that is, they can be created at run-time, assigned to variables, and passed to and returned from functions. This allows the construction of high-level concurrent features without explicit support for them in the model itself. We see how first-class events can be implemented in PVM, showing that it forms the base of a powerful concurrent-programming language. We also provide garbage-collection of processes, which simplifies selective communication and dealing with end-cases. The implementation promotes more widespread use of the flex...

Parallelism is going mainstream. Many chip manufactures are turning to multicore processor designs rather than scalar-oriented frequency increases as a way to get performance in their desktop, enterprise, and mobile processors. This endeavor is not likely to succeed long term if mainstream applications cannot be parallelized to take advantage of tens and eventually hundreds of hardware threads. Multicore architectures will differ in significant ways from their multisocket predecessors. For example, the communication to compute bandwidth ratio is likely to be higher, which will positively impact performance. More generally, multicore architectures introduce several new dimensions of variability in both performance guarantees and architectural contracts, such as the memory model, that may not stabilize for several generations of product. Programs written in functional or (constraint-)logic programming languages, or even in other languages with a controlled use of side effects, can greatly simplify parallel programming. Such declarative programming allows for a deterministic semantics even when the underlying implementation might be highly