Specialization of CML message-passing primitives

Reppy, John; Xiao, Yingqi

doi:10.1145/1190215.1190264

Cited by 19 publications

(16 citation statements)

References 23 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…This is accomplished by choosing between an abortEvt (used by the Timeout manager to signal a timeout) and receiving a chunk from file processing loop (lines [13][14][15][16][17][18][19][20]. When a timeout is detected, an asynchronous message is sent on channel arOut to notify the file processing loop of this fact (line 9); subsequent file processing then stops.…”

Section: Case Study: a Parallel Web-servermentioning

confidence: 99%

Composable asynchronous events

Ziarek

Sivaramakrishnan

Jagannathan

2011

Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

Although asynchronous communication is an important feature of many concurrent systems, building composable abstractions that leverage asynchrony is challenging. This is because an asynchronous operation necessarily involves two distinct threads of control -the thread that initiates the operation, and the thread that discharges it. Existing attempts to marry composability with asynchrony either entail sacrificing performance (by limiting the degree of asynchrony permitted), or modularity (by forcing natural abstraction boundaries to be broken).In this paper, we present the design and rationale for asynchronous events, an abstraction that enables composable construction of complex asynchronous protocols without sacrificing the benefits of abstraction or performance. Asynchronous events are realized in the context of Concurrent ML's first-class event abstraction [16]. We discuss the definition of a number of useful asynchronous abstractions that can be built on top of asynchronous events (e.g., composable callbacks) and provide a detailed case study of how asynchronous events can be used to substantially improve the modularity and performance of an I/O-intensive highly concurrent server application.

show abstract

Section: Case Study: a Parallel Web-servermentioning

confidence: 99%

Composable asynchronous events

Ziarek

Sivaramakrishnan

Jagannathan

2011

Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

show abstract

“…Inspired by Erlang [1], actors [6,37,47], and languages like Concurrent ML [40], Thorn supports concurrent and distributed programming through lightweight singlethreaded components that communicate asynchronously through message passing. Thorn components are logically separate.…”

Section: Related Workmentioning

confidence: 99%

Thorn

et al. 2009

View full text Add to dashboard Cite

Scripting languages enjoy great popularity due to their support for rapid and exploratory development. They typically have lightweight syntax, weak data privacy, dynamic typing, powerful aggregate data types, and allow execution of the completed parts of incomplete programs. The price of these features comes later in the software life cycle. Scripts are hard to evolve and compose, and often slow. An additional weakness of most scripting languages is lack of support for concurrency-though concurrency is required for scalability and interacting with remote services. This paper reports on the design and implementation of Thorn, a novel programming language targeting the JVM. Our principal contributions are a careful selection of features that support the evolution of scripts into industrial grade programs-e.g., an expressive module system, an optional type annotation facility for declarations, and support for concurrency based on message passing between lightweight, isolated processes. On the implementation side, Thorn has been designed to accommodate the evolution of the language itself through a compiler plugin mechanism and target the Java virtual machine.

show abstract

“…Recent work on implementing CML more efficiently has focused on static analysis of communication protocols (Reppy and Xiao 2007) and support for multiprocessors (Reppy and Xiao 2008). Stabilizers (Ziarek et al 2006) provide checkpointing for CML programs even in the presence of inter-thread communication and updates to shared memory.…”

Section: Related Workmentioning

confidence: 99%

Transactional events for ML

Effinger-Dean¹,

Kehrt²,

Grossman³

2008

Proceedings of the 13th ACM SIGPLAN International Conference on Functional Programming

View full text Add to dashboard Cite

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.

show abstract

Specialization of CML message-passing primitives

Cited by 19 publications

References 23 publications

Composable asynchronous events

Composable asynchronous events

Thorn

Transactional events for ML

Contact Info

Product

Resources

About