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

more »

... ion 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 iii iv ABSTRACT and actor-based concurrent programs suggests that the system allows type checking real-world Scala code with only few changes. Kurzfassung Nachrichtenbasierte Nebenläufigkeit mit Aktoren hat das Potential von Mehrkern-Prozessoren hin zu verteilten System zu skalieren. Es gibt jedoch noch mehrere Herausforderungen zu meistern bis aktorenbasierte Programmierung im grossen Massstab angewandt werden kann. Zum einen werden effiziente Implementierungen benötigt, die hochgradig skalierbar sind, um den Anforderungen moderner verteilter Anwendungen gerecht zu werden. Existierende Implementierungen für verbreitete Plattformen erreichen hohe Leistung und Skalierbarkeit nur auf Kosten von Flexibilität und Benutzbarkeit: Die Steuerfluss-Inversion, die ereignisbasierte Entwürfe mit sich bringen, und das Fehlen von feingranularer Nachrichtenfilterung führen oft dazu, dass die Anwendungslogik deutlich komplizierter wird. Zum anderen bringen Leistungs-und Interoperabilitätsanforderungen oft eine erhöhte Anfälligkeit für Synchronisierungsfehler mit sich: Die Wiederverwendung von Quellcode, der auf Synchronisierungsmechanismen einer niedrigeren Abstraktionsebene basiert, kann Livelocks zur Folge haben; das Senden von Referenzen auf nichtkonstante Daten als Nachrichten kann zu Dataraces führen. Diese Dissertation beschreibt den Entwurf und die Implementierung von Scala Actors. Unser System stellt die Effizienz und Skalierbarkeit zur Verfügung, die für grosse Systeme in Produktionsumgebungen erforderlich ist, wobei in manchen Fällen die Leistung anderer Javabasierter Aktorimplementierungen deutlich übertroffen wird. Gleichzeitig wird vom Programmiermodell (a) die Steuerfluss-Inversion ereignisbasierter Entwürfe vermieden, und (b) eine flexible Nachrichtenempfangsoperation unterstützt. Damit zeigen wir mit Hilfe experimenteller Ergebnisse, dass Erlang-Aktoren mit nur geringem Overhead im Vergleich zu einfacheren Programmiermodellen, die auf Steuerfluss-Inversion basieren, auf weitverbreiteten Plattformen implementiert werden können. Eine neuartige Integration von ereignisbasierten und threadbasierten Nebenläufigkeitsmodellen erlaubt eine sichere Wiederverwendung von lockbasiertem Quellcode innerhalb von Aktoren. Im letzten Teil der Dissertation führen wir einen neuen typbasierten Ansatz zur Isolierung von Aktoren ein, bei dem Dataraces mit Hilfe von eindeutigen Objektreferenzen vermieden werden. Einfache, statische Capabilities werden genutzt v vi KURZFASSUNG um sowohl eine flexible Form von Referenzeindeutigkeit als auch den höchstens einmaligen Verbrauch eindeutiger Referenzen sicherzustellen. Unsere wichtigste Innovation ist eine neuartige Methode, internes Aliasing eindeutiger Referenzen zu erlauben, was zu einem erstaunlich einfachen Typsystem führt; wir stellen einen vollständigen Beweis der Typsicherheit unseres Systems zur Verfügung. Mit Hilfe einer Implementierung als Plugin für den EPFL Scala-Compiler zeigen wir, dass das Typsystem in umfangreiche, produktionsreife Sprachen integriert werden kann. Praktische Experimente mit Collections und aktorbasierten, nebenläufigen Programmen zeigen, dass das System die Typprüfung praktisch benutzbaren Scala-Quellcodes erlaubt, wobei nur wenige zusätzliche Änderungen benötigt werden. Abstract iii Kurzfassung v