Orca: Ownership and Reference Count Collection for Actors

Orca is a novel garbage collection protocol for actor-based, object-oriented programming languages for multicore machines. It supports fully concurrent garbage collection, where an actor can trigger garbage collection at any time without synchronising with any other actor. It does so while supportin...

Full description

Bibliographic Details
Main Author: Vicente Franco, Juliana Patricia
Format: Text
Language:unknown
Published: Imperial College London 2018
Subjects:
Online Access:https://dx.doi.org/10.25560/67952
http://spiral.imperial.ac.uk/handle/10044/1/67952
id ftdatacite:10.25560/67952
record_format openpolar
spelling ftdatacite:10.25560/67952 2023-05-15T17:52:57+02:00 Orca: Ownership and Reference Count Collection for Actors Vicente Franco, Juliana Patricia 2018 https://dx.doi.org/10.25560/67952 http://spiral.imperial.ac.uk/handle/10044/1/67952 unknown Imperial College London Creative Commons Attribution NonCommercial No Derivatives Licence CC-BY-NC-ND Text ScholarlyArticle article-journal Doctor of Philosophy (PhD) 2018 ftdatacite https://doi.org/10.25560/67952 2021-11-05T12:55:41Z Orca is a novel garbage collection protocol for actor-based, object-oriented programming languages for multicore machines. It supports fully concurrent garbage collection, where an actor can trigger garbage collection at any time without synchronising with any other actor. It does so while supporting copy-less message passing and sharing of mutable state. By leveraging a type system’s guarantees of actor isolation, Orca can perform GC fully concurrently, without any form of barrier synchronisation in mutator threads, as commonly found in state-of-the-art concurrent collectors. Although Orca has been successfully implemented in Pony and in Encore, it had never been evaluated nor proven correct. Indeed, these are the two main contributions of this thesis. In this thesis, we model Orca and prove that it will never collect reachable objects (i.e., execution of programs managed by Orca will never result in dangling pointers) and that it will eventually deallocate all unreachable objects (i.e., execution of programs managed by Orca will never result in memory leaks). We model Orca in three steps: firstly, we define a set of requirements that must be ensured by the host language; secondly, assuming these requirements are in place, we model all the garbage collection related operations atomically; and thirdly, we extend our model to take into consideration that, in fact, in a fully concurrent system every instruction is interleaved with the execution of other operations. Moreover, we evaluate Orca ’s performance by measuring scalability, footprint, responsiveness and its overhead in the execution of a program. We perform this evaluation in the context of Pony, the language with which Orca was co-designed, and compare it against the JVM, BEAM and Boehm-Demers-Weiser. Text Orca DataCite Metadata Store (German National Library of Science and Technology)
institution Open Polar
collection DataCite Metadata Store (German National Library of Science and Technology)
op_collection_id ftdatacite
language unknown
description Orca is a novel garbage collection protocol for actor-based, object-oriented programming languages for multicore machines. It supports fully concurrent garbage collection, where an actor can trigger garbage collection at any time without synchronising with any other actor. It does so while supporting copy-less message passing and sharing of mutable state. By leveraging a type system’s guarantees of actor isolation, Orca can perform GC fully concurrently, without any form of barrier synchronisation in mutator threads, as commonly found in state-of-the-art concurrent collectors. Although Orca has been successfully implemented in Pony and in Encore, it had never been evaluated nor proven correct. Indeed, these are the two main contributions of this thesis. In this thesis, we model Orca and prove that it will never collect reachable objects (i.e., execution of programs managed by Orca will never result in dangling pointers) and that it will eventually deallocate all unreachable objects (i.e., execution of programs managed by Orca will never result in memory leaks). We model Orca in three steps: firstly, we define a set of requirements that must be ensured by the host language; secondly, assuming these requirements are in place, we model all the garbage collection related operations atomically; and thirdly, we extend our model to take into consideration that, in fact, in a fully concurrent system every instruction is interleaved with the execution of other operations. Moreover, we evaluate Orca ’s performance by measuring scalability, footprint, responsiveness and its overhead in the execution of a program. We perform this evaluation in the context of Pony, the language with which Orca was co-designed, and compare it against the JVM, BEAM and Boehm-Demers-Weiser.
format Text
author Vicente Franco, Juliana Patricia
spellingShingle Vicente Franco, Juliana Patricia
Orca: Ownership and Reference Count Collection for Actors
author_facet Vicente Franco, Juliana Patricia
author_sort Vicente Franco, Juliana Patricia
title Orca: Ownership and Reference Count Collection for Actors
title_short Orca: Ownership and Reference Count Collection for Actors
title_full Orca: Ownership and Reference Count Collection for Actors
title_fullStr Orca: Ownership and Reference Count Collection for Actors
title_full_unstemmed Orca: Ownership and Reference Count Collection for Actors
title_sort orca: ownership and reference count collection for actors
publisher Imperial College London
publishDate 2018
url https://dx.doi.org/10.25560/67952
http://spiral.imperial.ac.uk/handle/10044/1/67952
genre Orca
genre_facet Orca
op_rights Creative Commons Attribution NonCommercial No Derivatives Licence
op_rightsnorm CC-BY-NC-ND
op_doi https://doi.org/10.25560/67952
_version_ 1766160715714920448