Powered by
Conference Publishing Consulting

5th International Workshop on Programming Based on Actors, Agents, and Decentralized Control (AGERE! 2015), October 26, 2015, Pittsburgh, PA, USA

AGERE! 2015 – Proceedings

Contents - Abstracts - Authors
Title Page

Message from the Chairs
Welcome to the proceedings of the 5th International Workshop on Programming based on Actors, Agents, and Decentralized Control (AGERE!), Pittsburgh, PA, USA, October 26, 2015, co-located with SPLASH 2015. This latest edition of AGERE!, an ACM SIGPLAN workshop, confirms its role as 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.

Deny Capabilities for Safe, Fast Actors
Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, and Andy McNeil
(Imperial College London, UK)
Abstract Combining the actor-model with shared memory for performance is efficient but can introduce data-races. Existing approaches to static data-race freedom are based on uniqueness and immutability, but lack flexibility and high performance implementations. Our approach, based on deny properties, allows reading, writing and traversing unique references, introduces a new form of write uniqueness, and guarantees atomic behaviours.

Publisher's Version Article Search Video Info
Objects as Session-Typed Processes
Stephanie Balzer and Frank Pfenning
(Carnegie Mellon University, USA)
A key idea in object-oriented programming is that objects encapsulate state and interact with each other by message exchange. This perspective suggests a model of computation that is inherently concurrent (to facilitate simultaneous message exchange) and that accounts for the effect of message exchange on an object's state (to express valid sequences of state transitions). In this paper we show that such a model of computation arises naturally from session-based communication. We introduce an object-oriented programming language that has processes as its only objects and employs linear session types to express the protocols of message exchange and to reason about concurrency and state. Based on various examples we show that our language supports the typical patterns of object-oriented programming (e.g., encapsulation, dynamic dispatch, and subtyping) while guaranteeing session fidelity in a concurrent setting. In addition, we show that our language facilitates new forms of expression (e.g., type-directed reuse, internal choice), which are not available in current object-oriented languages. We have implemented our language in a prototype compiler.

Publisher's Version Article Search
Exploring AOP from an OOP Perspective
Rem W. Collier, Seán Russell, and David Lillis
(University College Dublin, Ireland)
Agent-Oriented Programming (AOP) researchers have successfully developed a range of agent programming languages that bridge the gap between theory and practice. Unfortunately, despite the in-community success of these languages, they have proven less compelling to the wider software engineering community. One of the main problems facing AOP language developers is the need to bridge the cognitive gap that exists between the concepts underpinning mainstream languages and those underpinning AOP. In this paper, we attempt to build such a bridge through a conceptual mapping between Object-Oriented Programming (OOP) and the AgentSpeak(L) family of AOP languages. This mapping explores how OOP concepts and the concurrent programming concept of threads relate to AgentSpeak(L) concepts. We then use our analysis of this mapping to drive the design of a new programming language entitled ASTRA.

Publisher's Version Article Search
Jacco: More Efficient Model Checking Toolset for Java Actor Programs
Arvin Zakeriyan, Ehsan Khamespanah, Marjan Sirjani, and Ramtin Khosravi
(University of Tehran, Iran; Reykjavik University, Iceland)
Actors provide concurrent, distributed, and event-driven autonomous objects which communicate asynchronously. Actor model benefits from higher level of scalability and actor programs are less error-prone in comparison to programs developed in other concurrent models. However, it does not prevent the racing and concurrency errors. So, to guarantee the correctness of mission critical actor programs, verification techniques like model checking are needed. Previously, Basset has been developed based on Java PathFinder, for model checking of Java actor programs. The message scheduling approach of Basset can cause false negative results as well as and early state space exploration. In addition, using Java PathFinder as the back-end model checker imposes the execution time inefficiencies. To resolve these issues, we developed Jacco as the direct model checking toolset for Java actor programs. We provided a new message scheduling approach and implemented it in Java. To illustrate how efficiently Jacco works, Basset and Jacco model checking results are compared for a number of case studies. We also used Jacco for the model checking of a real-world program in robotics systems.

Publisher's Version Article Search
Manyfold Actors: Extending the C++ Actor Framework to Heterogeneous Many-Core Machines using OpenCL
Raphael Hiesgen, Dominik Charousset, and Thomas C. Schmidt
(University of Applied Sciences Hamburg, Germany)
The processing power of modern many core hardware such as graphics processing units (GPUs) or coprocessors is increasingly available for general-purpose computation. The seamless way of actor systems to addresses concurrent and distributed programming makes it an attractive approach to integrate these novel architectures. In this work, we introduce OpenCL-enabled actors to the C++ Actor Framework (CAF). This offers a high level interface for accessing any OpenCL device without leaving the actor paradigm. The new type of actor is integrated into the runtime environment of CAF and gives rise to transparent message passing in distributed systems on heterogeneous hardware. New actors are instantiated by the function spawn_cl, while the runtime environment handles the discovery and setup of OpenCL devices in the background. Our evaluations on a commodity GPU, an Nvidia TESLA, and an Intel PHI reveal the expected linear scaling behavior when offloading larger work items. For sub-second duties, the efficiency of offloading was found to largely differ between devices. Moreover, our findings indicate a negligible overhead over programming the native OpenCL API.

Publisher's Version Article Search
Akka.js: Towards a Portable Actor Runtime Environment
Gianluca Stivan, Andrea Peruffo, and Philipp Haller
(UniCredit, Italy; KTH, Sweden)
Multiple mature implementations of the actor model of concurrency exist. Besides several ones available for the Java Virtual Machine, there are others, for example, written in SmallTalk or in C++, targeting native platforms or other virtual machines. Recently, runtime environments for platforms such as GPUs have also appeared.
However, so far, no full-featured, distributed actor runtime environment has allowed actor programs to run, unchanged, on both Java and JavaScript virtual machines. This paper describes our ongoing effort in providing a portable implementation of the widely-used Akka actor framework.

Publisher's Version Article Search

proc time: 0.06