A protocol for generalized occam
Software—Practice & Experience
Synchronous operations as first-class values
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
CML: A higher concurrent language
PLDI '91 Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementation
A multi-threaded higher-order user interface toolkit
User interface software
Concurrent programming in ML
An Effective Implementation for the Generalized Input-Output Construct of CSP
ACM Transactions on Programming Languages and Systems (TOPLAS)
Events in Haskell, and how to implement them
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
The Definition of Standard ML
Protocols for Non-Deterministic Communication over Synchronous Channels
IPPS '98 Proceedings of the 12th. International Parallel Processing Symposium on International Parallel Processing Symposium
Kill-safe synchronization abstractions
Proceedings of the ACM SIGPLAN 2004 conference on Programming language design and implementation
Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming
Specialization of CML message-passing primitives
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Iterative context bounding for systematic testing of multithreaded programs
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Status report: the manticore project
ML '07 Proceedings of the 2007 workshop on Workshop on ML
A scheduling framework for general-purpose parallel languages
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
The Art of Multiprocessor Programming
The Art of Multiprocessor Programming
Efficient parallel programming in Poly/ML and Isabelle/ML
Proceedings of the 5th ACM SIGPLAN workshop on Declarative aspects of multicore programming
Parallel computing with the Pi-calculus
Proceedings of the sixth workshop on Declarative aspects of multicore programming
Programming in Manticore, a heterogenous parallel functional language
CEFP'09 Proceedings of the Third summer school conference on Central European functional programming school
Implicitly threaded parallelism in manticore
Journal of Functional Programming
Garbage collection for multicore NUMA machines
Proceedings of the 2011 ACM SIGPLAN Workshop on Memory Systems Performance and Correctness
A monad for deterministic parallelism
Proceedings of the 4th ACM symposium on Haskell
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Reagents: expressing and composing fine-grained concurrency
Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation
Haskell vs. f# vs. scala: a high-level language features and parallelism support comparison
Proceedings of the 1st ACM SIGPLAN workshop on Functional high-performance computing
Feel different on the Java platform: the star programming language
Proceedings of the 2013 International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools
Proceedings of the 2nd ACM SIGPLAN workshop on Functional high-performance computing
| Hi-index | 0.00 |
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.