SPLASH Workshops 2017
2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH Workshops 2017)
Powered by
Conference Publishing Consulting

7th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control (AGERE 2017), October 23, 2017, Vancouver, BC, Canada

AGERE 2017 – Proceedings

Contents - Abstracts - Authors

7th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control (AGERE 2017)

Frontmatter

Title Page

Message from the Chairs
Welcome to the proceedings of the 7th International Workshop on Programming based on Actors, Agents, and Decentralized Control (AGERE!), co-located with SPLASH 2017. AGERE!, an ACM SIGPLAN workshop, keeps on being a unique venue in the research landscape bringing together researchers and practitioners interested in actors, agents and, more generally, high-level paradigms emphasizing decentralized control in thinking, modeling, developing, and reasoning about software systems.

Papers

Tree Topologies for Causal Message Delivery
Sebastian Blessing, Sylvan Clebsch, and Sophia Drossopoulou
(Imperial College London, UK; Microsoft Research, UK)
Causal message delivery, i.e. the requirement that messages are delivered in an order respecting their causal (logical) dependencies, is often mandated in the distributed setting. So far, causal message delivery has been implemented by augmenting messages with meta data information that allows the receiver (or the platform) to re-order, and if necessary hold back, messages upon receipt before processing. We propose that causal message delivery can be achieved by construction, simply by organizing the nodes of the distributed application into a tree topology, and without the need for any meta data in the messages. We present our ideas informally through an example application and then develop a formal model and prove that causal message delivery is preserved in tree-based networks.
Publisher's Version Article Search
Locality-Guided Scheduling in CAF
Sebastian Wölke, Raphael Hiesgen, Dominik Charousset, and Thomas C. Schmidt
(Hamburg University of Applied Sciences, Germany)
The C++ Actor Framework (CAF) was designed for using multiple, exchangeable schedulers with a default choice of random work stealing (RWS) for load-balancing. RWS is excellently scalable, and by choosing a random victim scheduling is kept simple with minimal information required. On the downside, it ignores data locality and misses opportunities to improve the application performance. In this paper, we contribute a locality-guided scheduling that exploits knowledge about the host system to adapt runtime deployment and thereby improves the performance of actor based applications. We implement and thoroughly analyze a CAF scheduler which considers the trade-off between communication locality and execution locality. The former describes the locality of communicating actors, while the latter the locality between a worker, which executes an actor, and the location of its data. Extensive performance evaluations show a performance gain for data intensive application of up to 25% on a 64 core NUMA machine.
Publisher's Version Article Search
Order Types: Static Reasoning about Message Races in Asynchronous Message Passing Concurrency
Mehdi Bagherzadeh and Hridesh Rajan
(Oakland University, USA; Iowa State University, USA)
Asynchronous message passing concurrency with higher level concurrency constructs including activities, asynchronous method invocations and future return values is gaining increased popularity, as an alternative to shared memory concurrency with lower level threads and locks. However, similar to data races in shared memory concurrency, message races in asynchronous message passing concurrency can make a program incorrect and cause bugs that are hard to find and fix. This paper presents order types, a novel type system for static reasoning about message races in asynchronous message passing concurrency. Order types are local, causal and polymorphic types with the following features. First, order types encode both communication and flow behaviors and their happens-before relations. Second, order types are designed for an imperative calculus with concurrent activities, asynchronous method invocations, future return values, wait-by-necessity synchronizations on futures, first-class activities and futures, recursion and dynamic creation of activities. Third, order types are polymorphic and introduce universally quantified type variables to encode unknown values of variables. Fourth, the order type of a module can be inferred modularly using only its implementation and independent of implementations of other modules in the program. Order types complement previous work on static reasoning about races in asynchronous message passing concurrency.
Publisher's Version Article Search
Sparrow: A DSL for Coordinating Large Groups of Heterogeneous Actors
Humberto Rodriguez Avila, Joeri De Koster, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
Actor-based programming is a well-established programming model for the development of concurrent and parallel systems. However, due to the asynchronous nature of its communication mechanism, it is often difficult to express coordination between multiple groups of actors. As a result, complex synchronization patterns are often difficult to express from within the actor model. The goal of this paper is to introduce a novel coordination model for actor-based programs. The model proposes advanced join-patterns over messages that improve the state of the art with four additional features: aggregation, sequencing, timing constraints, and transformations of sequence of messages. This paper also presents a prototype implementation of our model through a domain-specific language in Elixir.
Publisher's Version Article Search
A Principled Approach towards Debugging Communicating Event-Loops
Carmen Torres Lopez, Elisa Gonzalez Boix, Christophe Scholliers, Stefan Marr, and Hanspeter Mössenböck
(Vrije Universiteit Brussel, Belgium; Ghent University, Belgium; JKU Linz, Austria)
Since the multicore revolution, software systems are more and more inherently concurrent. Debugging such concurrent software systems is still hard, but in the recent years new tools and techniques are being proposed. For such novel debugging techniques, the main question is how to make sure that the proposed techniques are sufficiently expressive. In this paper, we explore a formal foundation that allows researchers to identify debugging techniques and assess how complete their features are in the context of message-passing concurrency. In particular, we describe a principled approach for defining the operational semantics of a debugger. Subsequently, we apply this technique to derive the operational semantics for a communicating event-loop debugger. We show that our technique scales for defining the semantics of a wide set of novel breakpoints recently proposed by systems such as REME-D and Kómpos. To the best of our knowledge, this is the first formal semantics for debugging asynchronous message passing-based concurrency models.
Publisher's Version Article Search
Actoverse: A Reversible Debugger for Actors
Kazuhiro Shibanai and Takuo Watanabe
(Tokyo Institute of Technology, Japan)
The Actor model is a concurrent computation model based on asynchronous message passing and shared-nothing principle. These characteristics and the absence of locks guarantee that actor-based programs can avoid simple concurrency bugs such as data races and deadlocks. However, they are not completely free from application level concurrency bugs that occur, for example, due to the indeterminate arrival order of messages. To assist discovering such bugs in actor-based systems, we designed and implemented Actoverse, a debugger that adopts reverse debugging and provides an interactive aid for controlling the arrival order of messages upon re-execution. This paper briefly presents its architecture and utilization in Akka-based applications.
Publisher's Version Article Search

proc time: 0.13