Table Of ContentSIAAM: Simple Isolation for an Abstract Actor Machine
Quentin Sabah
To cite this version:
Quentin Sabah. SIAAM: Simple Isolation for an Abstract Actor Machine. Distributed, Parallel, and
Cluster Computing [cs.DC]. Université de Grenoble, 2013. English. NNT: . tel-00933072
HAL Id: tel-00933072
https://theses.hal.science/tel-00933072
Submitted on 19 Jan 2014
HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est
archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents
entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non,
lished or not. The documents may come from émanant des établissements d’enseignement et de
teaching and research institutions in France or recherche français ou étrangers, des laboratoires
abroad, or from public or private research centers. publics ou privés.
THÈSE
Pour obtenir le grade de
DOCTEUR DE L’UNIVERSITÉ DE GRENOBLE
Spécialité : Informatique
Arrêtéministérial:
Présentéepar
Quentin Sabah
Thèse dirigée par Jean-Bernard Stefani
préparée au sein INRIA
et de EDMSTII
Siaam: Simple Isolation for an Abs-
tract Actor Machine
Thèse soutenue publiquement le 4 Décembre 2013,
devant le jury composé de :
Monsieur, Thomas Jensen
DirecteurdeRecherche,INRIARennes,Rapporteur
Monsieur, Gaël Thomas
MaîtredeConférences,LIP6,Rapporteur
Monsieur, Stéphane Ducasse
DirecteurdeRecherche,INRIALille,Examinateur
Monsieur, Germain Haugou
IngénieurR&D,STMicroelectronics,Examinateur
Monsieur, Jean-Bernard Stefani
DirecteurdeRecherche,INRIAGrenoble,Directeurdethèse
2
Remerciements
Je remercie les membre du jury, Stéphane Ducasse, Germain Haugou, Thomas Jensen
et Gaël Thomas, qui m’ont fait l’honneur d’évaluer les travaux rapportés dans le présent
document. Cette thèse n’aurait pas vu le jour sans l’implication de Philippe Guillaume qui
a impulsé le financement CIFRE auprès de STMicroelectronics. Enfin je suis reconnaissant à
Jean-Bernard Stefani de m’avoir accueilli depuis 2009 et durant près de cinq ans au sein des
équipes Sardes puis Spades à (l’)INRIA Rhône-Alpes.
Merci à mes nombreux collègues à ST et à l’INRIA grâce auxquels l’aventure scientifique et
technique a aussi pris une tournure bon enfant, chaleureuse et humaine.
Enfin mes relations amicales de plus longue date ont compté chaque jour et il en sera ainsi
encore longtemps.
3
4
Contents
Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1 Introduction 9
1.1 Informal overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.1.1 The actor model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.1.2 Siaam’s actor model . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2 Contributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.2.1 Contributions to the Open-Source communities . . . . . . . . . . . . . 17
1.3 Organization of this document . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2 State of the Art 19
2.1 Isolation in scalable concurrent systems . . . . . . . . . . . . . . . . . . . . . 19
2.1.1 Ownership-based isolation . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.1.2 Software-based processes. . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.1.3 Classloader isolation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.2 Static analyses for efficient concurrency . . . . . . . . . . . . . . . . . . . . . 30
2.3 Motivations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3 Formal specification of Siaam 35
3.1 Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2 HOL Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3 Abstract Syntax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3.1 Java’s features not offered by Jinja . . . . . . . . . . . . . . . . . . . . 42
3.4 Siaam Global Semantics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.4.1 Siaam Native API. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.4.2 Global State. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.4.3 Global Semantics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.4.4 Transitive ownership verification and transfer. . . . . . . . . . . . . . . 45
3.4.5 Actor actions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.4.6 Native Calls Semantics. . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.5 Single-Actor small-steps semantics . . . . . . . . . . . . . . . . . . . . . . . . 52
3.5.1 Single-Actor state. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.5.2 Jinja’s source language semantics. . . . . . . . . . . . . . . . . . . . . 53
3.5.3 Single-Actor semantics . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.5.4 Actors interleaving.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.6 The Siaam Virtual Machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.6.1 Single-Actor Machine Model. . . . . . . . . . . . . . . . . . . . . . . . 57
3.6.2 Operational Semantics. . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.6.3 Instructions execution . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
5
6 CONTENTS
3.6.4 Virtual Machine Interleaving. . . . . . . . . . . . . . . . . . . . . . . . 63
3.7 SIAAM isolation and formal proof . . . . . . . . . . . . . . . . . . . . . . . . 64
3.7.1 Abstract SIAAM: Types . . . . . . . . . . . . . . . . . . . . . . . . . . 64
3.7.2 Abstract SIAAM : Transition rules . . . . . . . . . . . . . . . . . . . . 66
3.7.3 Isolation property . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4 Ownership-based isolation for the JVM 77
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.1.1 JikesRVM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.1.2 Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.2 Virtual Machine’s core . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.2.1 Static contexts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
4.2.2 Object’s owners. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
4.2.3 Thread’s owner-ID. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
4.2.4 Opaque objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
4.2.5 Ownership transfer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.3 Ownership-based isolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
4.3.1 Owner-checking barriers.. . . . . . . . . . . . . . . . . . . . . . . . . . 92
4.3.2 Constructors and instance fields. . . . . . . . . . . . . . . . . . . . . . 93
4.3.3 Native methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
4.3.4 Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
4.3.5 Object finalizers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
4.4 Support for immutability and static variables . . . . . . . . . . . . . . . . . . 95
4.4.1 Final instance fields. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
4.4.2 Immutable objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
4.4.3 Arbitrary frozen objects . . . . . . . . . . . . . . . . . . . . . . . . . . 98
4.4.4 Static fields and Enum types . . . . . . . . . . . . . . . . . . . . . . . 99
4.4.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
4.5 Trusted programming models . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
4.5.1 Siaam Actors API. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
4.5.2 ActorFoundry. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
4.5.3 M:N cooperatively scheduled actors . . . . . . . . . . . . . . . . . . . 105
5 Static analysis and its usages 107
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
5.1.1 Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
5.2 Intermediate Representation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
5.2.1 Program representation. . . . . . . . . . . . . . . . . . . . . . . . . . . 109
5.2.2 IR language. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
5.2.3 Body’s control-flow graph. . . . . . . . . . . . . . . . . . . . . . . . . . 109
5.3 Standard analyses framework. . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
5.3.1 Program’s call graph. . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
5.3.2 Points-To Analysis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
5.3.3 Must-Alias Analysis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
5.3.4 Liveness Analysis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
5.4 The Siaam analysis framework. . . . . . . . . . . . . . . . . . . . . . . . . . . 115
5.4.1 Ownership-oriented programming models semantics. . . . . . . . . . . 115
5.4.2 Programming models API abstraction. . . . . . . . . . . . . . . . . . . 117
CONTENTS 7
5.5 Some programming models and their ownership-based semantics. . . . . . . . 117
5.5.1 Implicit owner-checks . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
5.5.2 Siaam actor programming model. . . . . . . . . . . . . . . . . . . . . . 118
5.5.3 Reflection-based message dispatch APIs . . . . . . . . . . . . . . . . . 120
5.6 The Siaam Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
5.6.1 Most conservative analysis. . . . . . . . . . . . . . . . . . . . . . . . . 123
5.6.2 Intra-procedural SafeEff side-effects propagation . . . . . . . . . . . . 124
5.6.3 Using the call graph information. . . . . . . . . . . . . . . . . . . . . . 127
5.6.4 Using accurate points-to information. . . . . . . . . . . . . . . . . . . 130
5.6.5 Inter-procedural Transferred Abstract Objets analysis . . . . . . . . . 132
5.6.6 Intra-procedural UnsafeEff side-effects propagation . . . . . . . . . . . 134
5.6.7 Propagation of the safe abstract objects towards the callees. . . . . . . 135
5.6.8 Escapement analysis for TAO . . . . . . . . . . . . . . . . . . . . . . . 136
5.7 Extension to frozen objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
5.7.1 The Read ownership state . . . . . . . . . . . . . . . . . . . . . . . . . 140
5.7.2 A programming model with frozen arrays . . . . . . . . . . . . . . . . 141
5.7.3 A programming model with frozen scalars . . . . . . . . . . . . . . . . 142
5.8 Usages of the Siaam analysis results . . . . . . . . . . . . . . . . . . . . . . . 142
5.8.1 Owner-check elimination . . . . . . . . . . . . . . . . . . . . . . . . . . 142
5.8.2 Programming assistant . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
5.9 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
6 Evaluation 147
6.1 Overall performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
6.1.1 Dacapo Benchmark . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
6.2 Micro benchmarks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
6.2.1 Zero-Copy vs. Deep-Copy. . . . . . . . . . . . . . . . . . . . . . . . . . 150
6.2.2 Graph-traversal optimizations . . . . . . . . . . . . . . . . . . . . . . . 151
6.2.3 Owner Check . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
6.2.4 Memory consumption . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
6.3 Owner-checking elimination . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
6.3.1 Actory Foundry Benchmarks . . . . . . . . . . . . . . . . . . . . . . . 153
7 Conclusion 155
7.1 Synthesis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
7.2 Future Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
7.2.1 Just-in-time whole-program analysis. . . . . . . . . . . . . . . . . . . . 156
7.2.2 Cohabitation with ownership types annotations. . . . . . . . . . . . . 156
7.2.3 Modular actor analysis. . . . . . . . . . . . . . . . . . . . . . . . . . . 157
7.2.4 Demand-driven Siaam analysis . . . . . . . . . . . . . . . . . . . . . . 157
A Jinja 159
B Siaam 163
C Abstracts 167
C.1 Résumé en français . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
C.2 English abstract . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
8 CONTENTS
Chapter 1
Introduction
It is now reasonable to state that scalability of concurrent systems is much more achiev-
able, both theoretically and technically, in the absence of shared state. First it allows one
to reason about the sequential behavior of each node independently of the others and the
global architecture. Second it guarantees race-free execution, thus avoiding need for synchro-
nization. In these systems, the state isolation property must be enforced by the inter-node
communication mechanism so that no piece of data may be simultaneously accessed by more
than one node, which would otherwise result in inconsistent observations and updates of the
same data by several nodes.
Message-passing has been widely adopted as the main communication scheme in concur-
rent systems. The exchanged data are copied from one node’s memory region to another’s.
Since messages are replicated in the receiver’s private state, each node of the system reads
and updates its own copy of the data, thus isolation is trivially preserved. Ideally, copy
operations are transparent whether memories are physically disjoint or not. To obtain the
best performance, it is preferable to pass a message in a zero-copy fashion when the commu-
nication takes place in the same shared memory. However, in order to preserve the isolation
propertyandavoiddataracewiththereceiver, thesendernodemustneveraccessthecontent
of that message again.
In this thesis we study isolation and message-passing in the context of concurrent object-
oriented programming. Messages are aggregates of objects living in a shared heap and passed
by reference for the hereinbefore reasons. Object-oriented languages allows arbitrary objects
aliasing, a beneficial feature for developers, raising serious difficulties to avoid data races
when mixed with reference passing. The challenge accepted by all the previous works on that
aspect consists in making sure a node cannot find or use any access path to the aggregate
of objects after passing it to another node. Symmetrically when a node receives a message
it must be the sole allowed accessor so that no other node may spy or alter the aggregate
concurrently.
Several variations of ownership and reference uniqueness have been extensively employed
in the past to control aliasing in object-oriented programming languages, and more recently
to address concurrency. Strikingly the vast majority rely on a set of statically checkable
typing rules, either requiring an annotation overhead or introducing object aliasing restric-
tions. Our contribution with Siaam is the demonstration of a purely run-time, actor-based,
annotation-free, aliasing-proof approach to concurrent state isolation allowing reference pass-
ing of arbitrary objects graphs. Even though we claim its extreme simplicity, Siaam is not a
paradigm shifter, its modus operandi may also be understood in traditional terms of owner-
ship and uniqueness, but in a rather dynamic way. Unlike statically-checked approaches that
9
Description:Monsieur, Gaël Thomas. Maître de Conférences, LIP6, Rapporteur. Monsieur, Stéphane Ducasse. Directeur de Recherche, INRIA Lille, Examinateur.
