Concurrent programming in ERLANG (2nd ed.)
Concurrent programming in ERLANG (2nd ed.)
Concurrent programming in ML
Communicating sequential processes
Communications of the ACM
Events in Haskell, and how to implement them
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
A Fully Abstract Semantics for a Concurrent Functional Language with Monadic Types
LICS '95 Proceedings of the 10th Annual IEEE Symposium on Logic in Computer Science
Language support for lightweight transactions
OOPSLA '03 Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications
Kill-safe synchronization abstractions
Proceedings of the ACM SIGPLAN 2004 conference on Programming language design and implementation
Composable memory transactions
Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming
AtomCaml: first-class atomicity via rollback
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
Haskell on a shared-memory multiprocessor
Proceedings of the 2005 ACM SIGPLAN workshop on Haskell
A transactional object calculus
Science of Computer Programming
Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming
Stabilizers: a modular checkpointing abstraction for concurrent functional programs
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
Transactions with isolation and cooperation
Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented programming systems and applications
High-level small-step operational semantics for transactions
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Journal of Functional Programming
Relaxed memory models: an operational approach
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Partial memoization of concurrency and communication
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
A concurrent ML library in concurrent Haskell
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
Lightweight checkpointing for concurrent ml
Journal of Functional Programming
Communicating memory transactions
Proceedings of the 16th ACM symposium on Principles and practice of parallel programming
Composable asynchronous events
Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation
Hi-index | 0.00 |
Transactional events (TE) are an approach to concurrent programming that enriches the first-class synchronous message-passing of Concurrent ML (CML) with a combinator that allows multiple messages to be passed as part of one all-or-nothing synchronization. Donnelly and Fluet (2006) designed and implemented TE as a Haskell library and demonstrated that it enables elegant solutions to programming patterns that are awkward or impossible in CML. However, both the definition and the implementation of TE relied fundamentally on the code in a synchronization not using mutable memory, an unreasonable assumption for mostly functional languages like ML where functional interfaces may have impure implementations. We present a definition and implementation of TE that supports ML-style references and nested synchronizations, both of which were previously unnecessary due to Haskell's more restrictive type system. As in prior work, we have a high-level semantics that makes nondeterministic choices such that synchronizations succeed whenever possible and a low-level semantics that uses search to implement the high-level semantics soundly and completely. The key design trade-off in the semantics is to allow updates to mutable memory without requiring the implementation to consider all possible thread interleavings. Our solution uses first-class heaps and allows interleavings only when a message is sent or received. We have used Coq to prove the high- and low-level semantics equivalent. We have implemented our approach by modifying the Objective Caml run-time system. By modifying the run-time system, rather than relying solely on a library, we can eliminate the potential for nonterminating computations within unsuccessful synchronizations to run forever.