More Like this

1. Toward a Lingua Franca for Deterministic Concurrent Systems

   https://doi.org/10.1145/3448128  

   Lohstroh, Marten; Menard, Christian; Bateni, Soroush; Lee, Edward_A (May 2021, ACM Transactions on Embedded Computing Systems)

   Many programming languages and programming frameworks focus on parallel and distributed computing. Several frameworks are based on actors, which provide a more disciplined model for concurrency than threads. The interactions between actors, however, if not constrained, admit nondeterminism. As a consequence, actor programs may exhibit unintended behaviors and are less amenable to rigorous testing. We show that nondeterminism can be handled in a number of ways, surveying dataflow dialects, process networks, synchronous-reactive models, and discrete-event models. These existing approaches, however, tend to require centralized control, pose challenges to modular system design, or introduce a single point of failure. We describe “reactors,” a new coordination model that combines ideas from several of these approaches to enable determinism while preserving much of the style of actors. Reactors promote modularity and allow for distributed execution. By using a logical model of time that can be associated with physical time, reactors also provide control over timing. Reactors also expose parallelism that can be exploited on multicore machines and in distributed configurations without compromising determinacy. 

   more » « less
2. High-performance Deterministic Concurrency Using Lingua Franca

   https://doi.org/10.1145/3617687  

   Menard, Christian; Lohstroh, Marten; Bateni, Soroush; Chorlian, Matthew; Deng, Arthur; Donovan, Peter; Fournier, Clément; Lin, Shaokai; Suchert, Felix; Tanneberger, Tassilo; et al (December 2023, ACM Transactions on Architecture and Code Optimization)

   Actor frameworks and similar reactive programming techniques are widely used for building concurrent systems. They promise to be efficient and scale well to a large number of cores or nodes in a distributed system. However, they also expose programmers to nondeterminism, which often makes implementations hard to understand, debug, and test. The recently proposed reactor model is a promising alternative that enables deterministic concurrency. In this article, we present an efficient, parallel implementation of reactors and demonstrate that the determinacy of reactors does not imply a loss in performance. To show this, we evaluateLingua Franca(LF), a reactor-oriented coordination language. LF equips mainstream programming languages with a deterministic concurrency model that automatically takes advantage of opportunities to exploit parallelism. Our implementation of the Savina benchmark suite demonstrates that, in terms of execution time, the runtime performance of LF programs even exceeds popular and highly optimized actor frameworks. We compare against Akka and CAF, which LF outperforms by 1.86× and 1.42×, respectively. 

   more » « less
3. Reactors: A Deterministic Model for Composable Reactive Systems

   https://doi.org/10.1007/978-3-030-41131-2_4  

   Lohstroh, Marten; Incer Romeo, Iñigo; Goens, Andrés; Derler, Patricia; Castrillon, Jeronimo; Lee, Edward A.; Sangiovanni-Vincentelli, Alberto (October 2019, Model-Based Design of Cyber Physical Systems (CyPhy'19))

   NOTE: DOI IS available but the nsfpar system rejects it: 10.1007/978-3-030-41131-2_4 This paper describes a component-based concurrent model of computation for reactive systems. The components in this model, featuring ports and hierarchy, are called reactors. The model leverages a semantic notion of time, an event scheduler, and a synchronous-reactive style of communication to achieve determinism. Reactors enable a programming model that ensures determinism, unless explicitly abandoned by the programmer. We show how the coordination of reactors can safely and transparently exploit parallelism, both in shared-memory and distributed systems. 

   more » « less
4. Functional Meaning for Parallel Streaming

   https://doi.org/10.1145/3729299  

   Rioux, Nick; Zdancewic, Steve (June 2025, Proceedings of the ACM on Programming Languages)

   Nondeterminism introduced by race conditions and message reorderings makes parallel and distributed programming hard. Nevertheless, promising approaches such as LVars and CRDTs address this problem by introducing a partial order structure on shared state that describes how the state evolves over time.Monotoneprograms that respect the order are deterministic. Datalog-inspired languages incorporate this idea of monotonicity in a first-class way but they are not general-purpose. We would like parallel and distributed languages to be as natural to use as any functional language, without sacrificing expressivity, and with a formal basis of study as appealing as the lambda calculus. This paper presents λ_∨, a core language for deterministic parallelism that embodies the ideas above. In λ_∨, values may increase over time according to astreaming orderand all computations are monotone with respect to that order. The streaming order coincides with the approximation order found in Scott semantics and so unifies the foundations of functional programming with the foundations of deterministic distributed computation. The resulting lambda calculus has a computationally adequate model rooted in domain theory. It integrates the compositionality and power of abstraction characteristic of functional programming with the declarative nature of Datalog. 

   more » « less
5. Actor Capabilities for Message Ordering

   https://doi.org/10.1007/978-3-032-05291-9_3  

   Gordon, Colin S (September 2025, Springer Nature Switzerland)

   Not AvailableActor systems are a flexible model of concurrent and distributed programming, which are efficiently implementable, and avoid many classic concurrency bugs by construction. However they must still deal with the challenge of messages arriving in unexpected orders. We describe an approach to restricting the orders in which actors send messages to each other, by equipping actor references—the handle used to address another actor—with a protocol restricting which message types can be sent to another actor and in which order using that particular actor reference. This endows the actor references with the properties of (flow-sensitive) static capabilities, which we call actor capabilities. By sending other actors only restricted actor references, actors may control which messages are sent in which orders by other actors. Rules for duplicating (splitting) actor references ensure that these restrictions apply even in the presence of delegation. The capabilities themselves restrict message send ordering, which may form the foundation for stronger forms of reasoning. We demonstrate this by layering an effect system over the base type system, where the relationships enforced between the actor capabilities and the effects of an actor’s behaviour ensure that an actor’s behaviour is always prepared to handle any message that may arrive. 

   more » « less