Fully concurrent garbage collection of actors on many-core machines

Abstract

Disposal of dead actors in actor-model languages is as important as disposal of unreachable objects in object-oriented languages. In current practice, programmers are required to either manually terminate actors, or they have to rely on garbage collection systems that monitor actor mutation through write barriers, thread coordination through locks etc. These techniques, however, prevent the collector from being fully concurrent.We developed a protocol that allows garbage collection to run fully concurrently with all actors. The main challenges in concurrent garbage collection is the detection of cycles of sleeping actors in the actors graph, in the presence of concurrent mutation of this graph. Our protocol is solely built on message passing: it uses deferred direct reference counting, a dedicated actor for the detection of (cyclic) garbage, and a confirmation protocol (to deal with the mutation of the actor graph).We present our ideas informally through an example, and then present a formal model, prove soundness and argue completeness. We have implemented the protocol as part of a runtime library. As a preliminary performance evaluation, we discuss the performance of our approach as currently used at a financial institution, and use four benchmarks from the literature to compare our approach with other actormodel systems. These preliminary results indicate that the overhead of our approach is small.

Run, agent, run! architecture and benchmarking of actor-based agents

“…The reasoning cycle ends when all intentions execute one step. This means that if in the reasoning cycle of an agent one of these steps is a time-consuming primitive action, the whole cycle will be blocked 8 . On the contrary a compiled agent does not have any notion of steps at run-time and the parallelism between intentions of the agent is also handled by the underlying concurrency model, in this case the Actor model.…”

“…Originally proposed as a tool for the theoretical understanding of concurrency, the Actor model serves now as the basis of several production-level solutions for distributed and asynchronous systems, and for reactive programming. These solutions include: Akka [15], a library developed for the JVM environment, enriched by a strong community with multiple complementary tools for distributed environments and stream processing; the C++ Actor Framework (CAF) [7], a library for creating concurrent programs in C++; Pony [8,9], an actor language for building robust parallel systems by providing data-race free isolation for actors. A comprehensive overview and benchmark over these works can be found in [3].…”

Run, actor, run: towards cross-actor language benchmarking

“…Pony is an actor language for building concurrent, parallel, type-safe, and high-performant systems [15][16][17]22]. Pony enforces actor isolation through a capability-based type system, which also provides guarantees to the runtime that are used to implement a zero-copying policy of shared data.…”

“…Akka runs on the JVM and thus may use whatever garbage collector the JVM supports (starting from JDK 9, the default is G1 [20]); which typically introduces some stop-the-world pauses and does not leverage actor isolation. CAF implements its own garbage collection using reference counting [1]; Pony has its own runtime and uses its own concurrent and parallel garbage collector [17] including actor collection [15].…”

Orca: GC and type system co-design for actor languages

“…Passive objects are collected using the underlying JVM's trace-based collector. Pony uses MAC [Clebsch and Drossopoulou 2013] to collect actors wheras Orca (and hence this paper) is only concerned with collection of objects.…”