Message-based concurrency using actors has the potential
to scale from multicore processors to distributed
systems. However, several challenges remain until
actor-based programming can be applied on a large scale.
First, actor implementations must be efficient and highly
scalable to meet the demands of large-scale distributed
applications. Existing implementations for mainstream
platforms achieve high performance and scalability only
at the cost of flexibility and ease of use: the control
inversion introduced by event-driven designs and the
absence of fine-grained message filtering complicate the
logic of application programs. Second, common
requirements pertaining to performance and
interoperability make programs prone to concurrency bugs:
reusing code that relies on lower-level synchronization
primitives may introduce livelocks; passing mutable
messages by reference may lead to data races. This thesis
describes the design and implementation of Scala Actors.
Our system offers the efficiency and scalability required
by large-scale production systems, in some cases
exceeding the performance of state-of-the-art JVM-based
actor implementations. At the same time, the programming
model (a) avoids the control inversion of event-driven
designs, and (b) supports a flexible message reception
operation. Thereby, we provide experimental evidence that
Erlang-style actors can be implemented on mainstream
platforms with only a modest overhead compared to simpler
actor abstractions based on inversion of control. A novel
integration of event-based and thread-based models of
concurrency enables a safe reuse of lock-based code from
inside actors. Finally, we introduce a new type-based
approach to actor isolation which avoids data races using
unique object references. Simple, static capabilities are
used to enforce a flexible notion of uniqueness and
at-most-once consumption of unique references. Our main
point of innovation is a novel way to support internal
aliasing of unique references which leads to a
surprisingly simple type system, for which we provide a
complete soundness proof. Using an implementation as a
plug-in for the EPFL Scala compiler, we show that the
type system can be integrated into full-featured
languages. Practical experience with collection classes
and actor-based concurrent programs suggests that the
system allows type checking real-world Scala code with
only few changes.
Thèse Ecole polytechnique fédérale de Lausanne EPFL, no
4874 (2010), Programme doctoral Informatique,
Communications et Information, Faculté informatique et
communications IC, Institut d'informatique fondamentale
IIF (Laboratoire de méthodes de programmation 1 LAMP1).
Dir.: Martin Odersky
%0 Thesis
%1 4874/THESES
%A Haller, Philipp
%C Lausanne
%D 2010
%I EPFL
%K actors isolation scala typesystem
%R 10.5075/epfl-thesis-4874
%T Isolated Actors for Race-Free Concurrent Programming
%U http://library.epfl.ch/theses/?nr=4874
%X Message-based concurrency using actors has the potential
to scale from multicore processors to distributed
systems. However, several challenges remain until
actor-based programming can be applied on a large scale.
First, actor implementations must be efficient and highly
scalable to meet the demands of large-scale distributed
applications. Existing implementations for mainstream
platforms achieve high performance and scalability only
at the cost of flexibility and ease of use: the control
inversion introduced by event-driven designs and the
absence of fine-grained message filtering complicate the
logic of application programs. Second, common
requirements pertaining to performance and
interoperability make programs prone to concurrency bugs:
reusing code that relies on lower-level synchronization
primitives may introduce livelocks; passing mutable
messages by reference may lead to data races. This thesis
describes the design and implementation of Scala Actors.
Our system offers the efficiency and scalability required
by large-scale production systems, in some cases
exceeding the performance of state-of-the-art JVM-based
actor implementations. At the same time, the programming
model (a) avoids the control inversion of event-driven
designs, and (b) supports a flexible message reception
operation. Thereby, we provide experimental evidence that
Erlang-style actors can be implemented on mainstream
platforms with only a modest overhead compared to simpler
actor abstractions based on inversion of control. A novel
integration of event-based and thread-based models of
concurrency enables a safe reuse of lock-based code from
inside actors. Finally, we introduce a new type-based
approach to actor isolation which avoids data races using
unique object references. Simple, static capabilities are
used to enforce a flexible notion of uniqueness and
at-most-once consumption of unique references. Our main
point of innovation is a novel way to support internal
aliasing of unique references which leads to a
surprisingly simple type system, for which we provide a
complete soundness proof. Using an implementation as a
plug-in for the EPFL Scala compiler, we show that the
type system can be integrated into full-featured
languages. Practical experience with collection classes
and actor-based concurrent programs suggests that the
system allows type checking real-world Scala code with
only few changes.
@phdthesis{4874/THESES,
abstract = {Message-based concurrency using actors has the potential
to scale from multicore processors to distributed
systems. However, several challenges remain until
actor-based programming can be applied on a large scale.
First, actor implementations must be efficient and highly
scalable to meet the demands of large-scale distributed
applications. Existing implementations for mainstream
platforms achieve high performance and scalability only
at the cost of flexibility and ease of use: the control
inversion introduced by event-driven designs and the
absence of fine-grained message filtering complicate the
logic of application programs. Second, common
requirements pertaining to performance and
interoperability make programs prone to concurrency bugs:
reusing code that relies on lower-level synchronization
primitives may introduce livelocks; passing mutable
messages by reference may lead to data races. This thesis
describes the design and implementation of Scala Actors.
Our system offers the efficiency and scalability required
by large-scale production systems, in some cases
exceeding the performance of state-of-the-art JVM-based
actor implementations. At the same time, the programming
model (a) avoids the control inversion of event-driven
designs, and (b) supports a flexible message reception
operation. Thereby, we provide experimental evidence that
Erlang-style actors can be implemented on mainstream
platforms with only a modest overhead compared to simpler
actor abstractions based on inversion of control. A novel
integration of event-based and thread-based models of
concurrency enables a safe reuse of lock-based code from
inside actors. Finally, we introduce a new type-based
approach to actor isolation which avoids data races using
unique object references. Simple, static capabilities are
used to enforce a flexible notion of uniqueness and
at-most-once consumption of unique references. Our main
point of innovation is a novel way to support internal
aliasing of unique references which leads to a
surprisingly simple type system, for which we provide a
complete soundness proof. Using an implementation as a
plug-in for the EPFL Scala compiler, we show that the
type system can be integrated into full-featured
languages. Practical experience with collection classes
and actor-based concurrent programs suggests that the
system allows type checking real-world Scala code with
only few changes.},
added-at = {2012-09-26T01:22:59.000+0200},
address = {Lausanne},
affiliation = {EPFL},
author = {Haller, Philipp},
biburl = {https://www.bibsonomy.org/bibtex/2cd477e5d235cb95e96bcc05eaaa72e27/gron},
details = {http://infoscience.epfl.ch/record/151999},
documenturl = {http://biblion.epfl.ch/EPFL/theses/2010/4874/EPFL_TH4874.pdf},
doi = {10.5075/epfl-thesis-4874},
interhash = {546cc75f3418801af917f266be27b441},
intrahash = {cd477e5d235cb95e96bcc05eaaa72e27},
keywords = {actors isolation scala typesystem},
oai-id = {oai:infoscience.epfl.ch:151999},
oai-set = {thesis-urn},
pagecount = {173},
publisher = {EPFL},
status = {PUBLISHED},
thesis-note = {Thèse Ecole polytechnique fédérale de Lausanne EPFL, no
4874 (2010), Programme doctoral Informatique,
Communications et Information, Faculté informatique et
communications IC, Institut d'informatique fondamentale
IIF (Laboratoire de méthodes de programmation 1 LAMP1).
Dir.: Martin Odersky},
timestamp = {2012-09-26T01:22:59.000+0200},
title = {Isolated {A}ctors for {R}ace-{F}ree {C}oncurrent {P}rogramming},
unit = {LAMP},
url = {http://library.epfl.ch/theses/?nr=4874},
urn = {urn:nbn:ch:bel-epfl-thesis4874-0},
year = 2010
}