Search

Automatic garbage collection (GC) prevents certain kinds of bugs and reduces programming overhead. GC techniques for sequential programs are based on reachability analysis. However, testing reachability from a root set is inadequate for determining whether an actor is garbage because an unreachable actor may send a message to a reachable actor. Instead, it is sufficient to check termination (sometimes also called quiescence): an actor is terminated if it is not currently processing a message and cannot receive a message in the future. Moreover, many actor frameworks provide all actors with access to file I/O or external storage; without inspecting an actor's internal code, it is necessary to check that the actor has terminated to ensure that it may be garbage collected in these frameworks. Previous algorithms to detect actor garbage require coordination mechanisms such as causal message delivery or nonlocal monitoring of actors for mutation. Such coordination mechanisms adversely affect concurrency and are therefore expensive in distributed systems. We present a low-overhead reference listing technique (called DRL) for termination detection in actor systems. DRL is based on asynchronous local snapshots and message-passing between actors. This enables a decentralized implementation and transient network partition tolerance. The paper provides a formal description of DRL, shows that all actors identified as garbage have indeed terminated (safety), and that all terminated actors--under certain reasonable assumptions--will eventually be identified (liveness)., Comment: 23 pages, 7 figures. To appear in the proceedings of CONCUR 2020. Version 2: Fixed TeX error that omitted predicates in the third line of the Send rule: Actor $A$ must have active refobs $x$ and $y_1 \dots y_n$

The AGERE! workshop1 has been organized with the ACM SPLASH conference since 2011. The workshop has brought together researchers in programming systems, languages, and applications based on actors, active/concurrent objects, agents, and more broadly, high-level programming paradigms which facilitate decentralized control. The goal of the workshop is to promote use of such paradigms to address the problem of developing software for complex, real-world applications. The AGERE workshop is a follow on to workshops on Object-based Concurrent Programming which were organized twenty years earlier in conjunction with OOPSLA [1-3]. In the last two decades, concurrency and distribution have become part of everyday programming. In this context, the objective of AGERE! is to foster the development and adoption of high-level programming paradigms embracing concurrency at the core of the developed abstractions and constructs. This special issue collects extended and enhanced versions of selected papers from AGERE! 2011 and 2012 which underwent additional review cycles.

Concurrent object-oriented programming in Beta is based on semaphores and coroutines and the ability to define high-level concurrency abstractions like monitors, and rendezvous-based communication, and their associated schedulers. The coroutine mechanism of SIMULA has been generalized into the notions of concurrent and alternating objects. Alternating objects may be used to start a cooperative thread for each possible blocking communication and is thus an alternative to asynchronous messages and guarded commands. Beta like SIMULA, the first OO language, was designed as a language for modeling as well as programming, and we describe how this has had an impact on the design of the language. Although Beta supports the definition of high-level concurrency abstractions, the use of these rely on the discipline of the programmer as is the case for Java and other mainstream OO languages. We introduce the notion of subpattern (including subclass) restrictions as a mechanism for defining safe concurrency abstractions. Subpattern restrictions have been implemented in a new experimental version of Beta, called xBeta Concurrent object-oriented programming in Beta is based on semaphores and coroutines and the ability to define high-level concurrency abstractions like monitors, and rendezvous-based communication, and their associated schedulers. The coroutine mechanism of SIMULA has been generalized into the notions of concurrent and alternating objects. Alternating objects may be used to start a cooperative thread for each possible blocking communication and is thus an alternative to asynchronous messages and guarded commands. Beta like SIMULA, the first OO language, was designed as a language for modeling as well as programming, and we describe how this has had an impact on the design of the language. Although Beta supports the definition of high-level concurrency abstractions, the use of these rely on the discipline of the programmer as is the case for Java and other mainstream OO languages. We introduce the notion of subpattern (including subclass) restrictions as a mechanism for defining safe concurrency abstractions. Subpattern restrictions have been implemented in a new experimental version of Beta, called xBeta