DOCSLIB.ORG

Copyright by David Wilson Kitchin 2013

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

Copyright by David Wilson Kitchin 2013 The Dissertation Committee for David Wilson Kitchin certifies that this is the approved version of the following dissertation: Orchestration and Atomicity Committee: Jayadev Misra, Supervisor William Cook, Supervisor Don Batory Keshav Pingali Dan Grossman Orchestration and Atomicity by David Wilson Kitchin, B.S.C.S. Dissertation Presented to the Faculty of the Graduate School of The University of Texas at Austin in Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy The University of Texas at Austin August 2013 This dissertation is dedicated to my mother and father, whose boundless love and support have made all of this possible. Acknowledgments First, I must express my gratitude to my best friend, Kristine Butler, without whose unwavering support I could never have completed this journey. I am also deeply grateful to my good friends Chris Lundberg and Mercedes Vaughn, who have given me a place to call home for the past three years, and whose wonderful companionship I have continually enjoyed. I am thankful every day for my loving, quirky, and brilliant family. I am grateful for my excellent advisor and mentor, Jay Misra, so much so that I am not sure how to put it into words. We have worked together for eight years, and our collaborations have always been productive and enjoyable. He has always treated me with respect, even when I have ignored his guidance or strained his patience. Jay is a great scholar, and I look forward to opportunities to work with him again in the future. My gratitude extends to all of the members of the Orc Research Group, past and present, who have each in their own way made the group a lively and interesting hub of great ideas and vigorous discussion. My current co-conspirators, John Thywissen and Arthur Peters, are at the top of that list. I would like to thank the other four members of my dissertation commit- tee | William Cook, Don Batory, Keshav Pingali, and Dan Grossman | for their patience throughout my long and difficult writing process. I would like to thank all of the organizers, lecturers, and participants who v attended the Summer School on Language-Based Techniques for Concurrent and Distributed Software at the University of Oregon, in 2006. That confluence of great ideas and talented minds gave me the initial spark that led, over the course of seven years, to the development of Ora. I am indebted to Frank Pfenning, who managed to teach me enough about programming language theory in a single semester to last me through a decade of exploration and research, with more still to come. I am also indebted to Steven Rudich, who managed to teach me enough about the magic of computer science in a single semester to last me through a dozen years of programming and proving, with more still to come. And I am indebted to a whole host of other excellent teachers for their innumerable lessons: Stephen Gregory, Meg Curran, Richard Monroe, Paul Jourcin, Mark Stehlik, Klaus Sutner, Patricia Carpenter, and so many others. Lastly, I would like to thank Zo¨eKeating for her beautiful music, which has helped me to endure a long journey and to remain an optimist throughout. David Wilson Kitchin The University of Texas at Austin August 2013 vi Orchestration and Atomicity Publication No. David Wilson Kitchin, Ph.D. The University of Texas at Austin, 2013 Supervisor: Jayadev Misra Co-supervisor: William Cook This dissertation presents the concurrent programming language Ora, an extension of the Orc orchestration language with the capability to execute transactions. A new formal definition of transactions is given, in terms of two complementary properties: atomicity and coatomicity. These properties are described in terms of a partial order of events, rather than as properties of a totally ordered program trace. Atomicity and coatomicity are ensured in Ora programs by a novel algorithm for multiversion concurrency control. vii Contents Acknowledgments v Abstract vii Chapter 1 Introduction 1 1.1 Controlling Structured Concurrency . .1 1.2 Contributions of This Thesis . .3 Chapter 2 Orc 6 2.1 Orc as a Process Calculus . .6 2.1.1 Values . .7 2.1.2 Sites . .7 2.1.3 Stop . .8 2.1.4 Combinators . .8 2.1.5 Functions . .9 2.2 Orc as a Programming Language . 10 2.2.1 val ................................ 11 2.2.2 Operators . 11 2.2.3 Conditionals . 11 2.2.4 Flattening . 12 2.2.5 Structured Data . 13 2.2.6 Patterns . 13 2.2.7 Join . 14 2.2.8 Enhanced Function Definitions . 14 2.2.9 Mutable State . 15 viii 2.3 Formal Semantics . 17 2.3.1 Syntax . 18 2.3.2 Expression Semantics . 19 2.3.3 Environment Semantics . 21 2.3.4 Site Semantics . 25 Chapter 3 A Survey of Concurrency Control Methods 32 3.1 Locks . 33 3.2 Messages . 35 3.3 Transactions . 37 3.3.1 New Approaches to Transactional Memory . 38 3.3.2 Limitations of Transactional Memory . 40 Chapter 4 A General Principle of Concurrency Control 42 4.1 Representation of Concurrent Events . 43 4.1.1 Causality in Programs . 44 4.1.2 Causality at Sites . 45 4.2 Controlling Concurrent Events . 47 4.2.1 Defining Atoms . 53 4.2.2 Examples . 53 4.2.3 Redefining Atoms . 75 4.3 Related Work . 76 Chapter 5 Ora 78 5.1 The atomic combinator . 79 5.1.1 Unary atomic .......................... 79 5.1.2 The Abort Site . 79 5.2 Atomic Choice . 81 5.3 Writing Programs in Ora . 85 5.3.1 Account Transfer . 85 5.3.2 Permutation . 86 5.3.3 Dining Philosophers . 88 5.3.4 Atomic Timeout . 90 5.3.5 Retry Tactics . 91 5.3.6 Job Priority . 93 ix Chapter 6 Implementing Ora 95 6.1 Transactions . 96 6.1.1 Transactional Sites . 96 6.2 Observation . 98 6.2.1 Version Information . 99 6.2.2 Observing States . 100 6.2.3 Blocked Calls . 104 6.2.4 Tracking Causality . 105 6.2.5 Relationship to Distributed Snapshot . 107 6.3 Merging . 108 6.3.1 Resource Versions . 109 6.3.2 Commit . 110 Chapter 7 Formal Semantics of Ora 114 7.1 Syntax of Ora . 116 7.2 Internal Semantics . 118 7.2.1 Halting Judgment . 118 7.2.2 Execution Judgment . 120 7.3 External Semantics . 129 7.3.1 Environment and Event Grammar . 129 7.3.2 Site Transitions . 130 7.3.3 External Transitions . 131 7.4 Environment Operations . 135 7.4.1 Environment Filtering and Mapping . 135 7.4.2 Image . 136 7.4.3 State . 136 7.5 Observer Semantics . 138 7.5.1 Snapshot Judgment . 138 7.5.2 Boundary Judgment . 139 7.5.3 Observe Judgment . 140 7.6 Commit Semantics . 141 7.6.1 Merge Operation . 141 7.6.2 Graft Judgment . 142 7.6.3 Participants . 142 x 7.6.4 Boundary? Judgment . 143 7.6.5 Commit Judgment . 143 7.6.6 Conflict Judgment . 144 7.6.7 The Abort site . 144 7.7 Resource Semantics . 146 7.7.1 Guard . 146 7.7.2 Ref . 148 7.7.3 Cell . 150 7.7.4 Channel . 151 7.7.5 Semaphore . 154 Chapter 8 Formal Properties of Ora 156 8.1 Atomicity and Coatomicity . 156 8.1.1 Notation . 156 8.1.2 Internal Causality . 157 8.1.3 External Causality . 158 8.1.4 Virtual Causality . 159 8.1.5 Relevance . 162 8.1.6 The Bubble Conjecture . 163 8.2 Consistency . 163 Chapter 9 Discussion 166 9.1 Choosing Resources . 166 9.2 Incorporating Time . 167 9.3 Blocking . ..
Recommended publications
  • Concepts of Concurrent Programming Summary of the Course in Spring 2011 by Bertrand Meyer and Sebastian Nanz

    Concepts of Concurrent Programming Summary of the Course in Spring 2011 by Bertrand Meyer and Sebastian Nanz

    Concepts of Concurrent Programming Summary of the course in spring 2011 by Bertrand Meyer and Sebastian Nanz Stefan Heule 2011-05-28 Licence: Creative Commons Attribution-Share Alike 3.0 Unported (http://creativecommons.org/licenses/by-sa/3.0/) Contents 1 Introduction .......................................................................................................................................... 4 1.1 Ambdahl’s Law .............................................................................................................................. 4 1.2 Basic Notions ................................................................................................................................. 4 1.2.1 Multiprocessing ..................................................................................................................... 4 1.2.2 Multitasking .......................................................................................................................... 4 1.2.3 Definitions ............................................................................................................................. 4 1.2.4 The Interleaving Semantics ................................................................................................... 5 1.3 Transition Systems and LTL ........................................................................................................... 6 1.3.1 Syntax and Semantics of Linear-Time Temporal Logic.......................................................... 7 1.3.2 Safety and Liveness Properties
  • Implementing a Transformation from BPMN to CSP+T with ATL: Lessons Learnt

    Implementing a Transformation from BPMN to CSP+T with ATL: Lessons Learnt

    Implementing a Transformation from BPMN to CSP+T with ATL: Lessons Learnt Aleksander González1, Luis E. Mendoza1, Manuel I. Capel2 and María A. Pérez1 1 Processes and Systems Department, Simón Bolivar University PO Box 89000, Caracas, 1080-A, Venezuela 2 Software Engineering Department, University of Granada Aynadamar Campus, 18071, Granada, Spain Abstract. Among the challenges to face in order to promote the use of tech- niques of formal verification in organizational environments, there is the possi- bility of offering the integration of features provided by a Model Transforma- tion Language (MTL) as part of a tool very used by business analysts, and from which formal specifications of a model can be generated. This article presents the use of MTL ATLAS Transformation Language (ATL) as a transformation artefact within the domains of Business Process Modelling Notation (BPMN) and Communicating Sequential Processes + Time (CSP+T). It discusses the main difficulties encountered and the lessons learnt when building BTRANSFORMER; a tool developed for the Eclipse platform, which allows us to generate a formal specification in the CSP+T notation from a business process model designed with BPMN. This learning is valid for those who are interested in formalizing a Business Process Modelling Language (BPML) by means of a process calculus or another formal notation. 1 Introduction Business Processes (BP) must be properly and formally specified in order to be able to verify properties, such as scope, structure, performance, capacity, structural consis- tency and concurrency, i.e., those properties of BP which can provide support to the critical success factors of any organization. Formal specification languages and proc- ess algebras, which allow for the exhaustive verification of BP behaviour [17], are used to carry out the formalization of models obtained from Business Process Model- ling (BPM).
  • Bisimulations in the Join-Calculus

    Bisimulations in the Join-Calculus

    Bisimulations in the Join-Calculus C´edricFournet a Cosimo Laneve b,1 aMicrosoft Research, 1 Guildhall Street, Cambridge, U.K. b Dipartimento di Scienze dell’Informazione, Universit`adi Bologna, Mura Anteo Zamboni 7, 40127 Bologna, Italy. Abstract We develop a theory of bisimulations in the join-calculus. We introduce a refined operational model that makes interactions with the environment explicit, and dis- cuss the impact of the lexical scope discipline of the join-calculus on its extensional semantics. We propose several formulations of bisimulation and establish that all formulations yield the same equivalence. We prove that this equivalence is finer than barbed congruence, but that both relations coincide in the presence of name matching. Key words: asynchronous processes; barbed congruence; bisimulation; chemical semantics; concurrency; join-calculus; locality; name matching; pi-calculus. 1 Introduction The join-calculus is a recent formalism for modeling mobile systems [15,17]. Its main motivation is to relate two crucial issues in concurrency: distributed implementation and formal semantics. To this end, the join-calculus enforces a strict lexical scope discipline over the channel names that appear in processes: names can be sent and received, but their input capabilities cannot be affected by the receivers. This is the locality property. 2 Locality yields a realistic distributed model, because the communication prim- itives of the calculus can be directly implemented via standard primitives of 1 This work is partly supported by the ESPRIT CONFER-2 WG-21836 2 The term locality is a bit overloaded in the literature; here, names are locally defined inasmuch as no external definition may interfere; this is the original meaning of locality in the chemical semantics of Banˆatre et al.
  • Deadlock Analysis of Wait-Notify Coordination Laneve Cosimo, Luca Padovani

    Deadlock Analysis of Wait-Notify Coordination Laneve Cosimo, Luca Padovani

    Deadlock Analysis of Wait-Notify Coordination Laneve Cosimo, Luca Padovani To cite this version: Laneve Cosimo, Luca Padovani. Deadlock Analysis of Wait-Notify Coordination. The Art of Modelling Computational Systems: A Journey from Logic and Concurrency to Security and Privacy - Essays Dedicated to Catuscia Palamidessi on the Occasion of Her 60th Birthday, Nov 2019, Paris, France. hal-02430351 HAL Id: hal-02430351 https://hal.archives-ouvertes.fr/hal-02430351 Submitted on 7 Jan 2020 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. Deadlock Analysis of Wait-Notify Coordination Cosimo Laneve1[0000−0002−0052−4061] and Luca Padovani2[0000−0001−9097−1297] 1 Dept. of Computer Science and Engineering, University of Bologna { INRIA Focus 2 Dipartimento di Informatica, Universit`adi Torino Abstract. Deadlock analysis of concurrent programs that contain co- ordination primitives (wait, notify and notifyAll) is notoriously chal- lenging. Not only these primitives affect the scheduling of processes, but also notifications unmatched by a corresponding wait are silently lost. We design a behavioral type system for a core calculus featuring shared objects and Java-like coordination primitives. The type system is based on a simple language of object protocols { called usages { to determine whether objects are used reliably, so as to guarantee deadlock freedom.
  • The Beacon Calculus: a Formal Method for the flexible and Concise Modelling of Biological Systems

    The Beacon Calculus: a Formal Method for the flexible and Concise Modelling of Biological Systems

    bioRxiv preprint doi: https://doi.org/10.1101/579029; this version posted November 26, 2019. The copyright holder for this preprint (which was not certified by peer review) is the author/funder, who has granted bioRxiv a license to display the preprint in perpetuity. It is made available under aCC-BY 4.0 International license. The Beacon Calculus: A formal method for the flexible and concise modelling of biological systems Michael A. Boemo1∗ Luca Cardelli2 Conrad A. Nieduszynski3 1Department of Pathology, University of Cambridge 2Department of Computer Science, University of Oxford 3Genome Damage and Stability Centre, University of Sussex Abstract Biological systems are made up of components that change their actions (and interactions) over time and coordinate with other components nearby. Together with a large state space, the complexity of this behaviour can make it difficult to create concise mathematical models that can be easily extended or modified. This paper introduces the Beacon Calculus, a process algebra designed to simplify the task of modelling interacting biological components. Its breadth is demonstrated by creating models of DNA replication dynamics, the gene expression dynamics in response to DNA methylation damage, and a multisite phosphorylation switch. The flexibility of these models is shown by adapting the DNA replication model to further include two topics of interest from the literature: cooperative origin firing and replication fork barriers. The Beacon Calculus is supported with the open-source simulator bcs (https://github.com/MBoemo/bcs.git) to allow users to develop and simulate their own models. Author summary Simulating a model of a biological system can suggest ideas for future experiments and help ensure that conclusions about a mechanism are consistent with data.
  • Kotlin Coroutines Deep Dive Into Bytecode #Whoami

    Kotlin Coroutines Deep Dive Into Bytecode #Whoami

    Kotlin Coroutines Deep Dive into Bytecode #whoami ● Kotlin compiler engineer @ JetBrains ● Mostly working on JVM back-end ● Responsible for (almost) all bugs in coroutines code Agenda I will talk about ● State machines ● Continuations ● Suspend and resume I won’t talk about ● Structured concurrency and cancellation ● async vs launch vs withContext ● and other library related stuff Agenda I will talk about Beware, there will be code. A lot of code. ● State machines ● Continuations ● Suspend and resume I won’t talk about ● Structured concurrency and cancellation ● async vs launch vs withContext ● and other library related stuff Why coroutines ● No dependency on a particular implementation of Futures or other such rich library; ● Cover equally the "async/await" use case and "generator blocks"; ● Make it possible to utilize Kotlin coroutines as wrappers for different existing asynchronous APIs (such as Java NIO, different implementations of Futures, etc). via coroutines KEEP Getting Lazy With Kotlin Pythagorean Triples fun printPythagoreanTriples() { for (i in 1 until 100) { for (j in 1 until i) { for (k in i until 100) { if (i * i + j * j < k * k) { break } if (i * i + j * j == k * k) { println("$i^2 + $j^2 == $k^2") } } } } } Pythagorean Triples fun printPythagoreanTriples() { for (i in 1 until 100) { for (j in 1 until i) { for (k in i until 100) { if (i * i + j * j < k * k) { break } if (i * i + j * j == k * k) { println("$i^2 + $j^2 == $k^2") } } } } } Pythagorean Triples fun printPythagoreanTriples() { for (i in 1 until 100) { for (j
  • Contention in Structured Concurrency: Provably Efficient Dynamic Non-Zero Indicators for Nested Parallelism

    Contention in Structured Concurrency: Provably Efficient Dynamic Non-Zero Indicators for Nested Parallelism

    Contention in Structured Concurrency: Provably Efficient Dynamic Non-Zero Indicators for Nested Parallelism Umut A. Acar1;2 Naama Ben-David 1 Mike Rainey 2 January 16, 2017 CMU-CS-16-133 School of Computer Science Carnegie Mellon University Pittsburgh, PA 15213 A short version of this work appears in the proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming 2017 (PPoPP '17). 1Carnegie Mellon University, Pittsburgh, PA 2Inria-Paris Keywords: concurrent data structures, non-blocking data structures, contention, nested parallelism, dependency counters Abstract Over the past two decades, many concurrent data structures have been designed and im- plemented. Nearly all such work analyzes concurrent data structures empirically, omit- ting asymptotic bounds on their efficiency, partly because of the complexity of the analysis needed, and partly because of the difficulty of obtaining relevant asymptotic bounds: when the analysis takes into account important practical factors, such as contention, it is difficult or even impossible to prove desirable bounds. In this paper, we show that considering structured concurrency or relaxed concurrency mod- els can enable establishing strong bounds, also for contention. To this end, we first present a dynamic relaxed counter data structure that indicates the non-zero status of the counter. Our data structure extends a recently proposed data structure, called SNZI, allowing our structure to grow dynamically in response to the increasing degree of concurrency in the system. Using the dynamic SNZI data structure, we then present a concurrent data structure for series-parallel directed acyclic graphs (sp-dags), a key data structure widely used in the implementation of modern parallel programming languages.
  • Oolong: a Concurrent Object Calculus for Extensibility and Reuse

    Oolong: a Concurrent Object Calculus for Extensibility and Reuse

    OOlong: A Concurrent Object Calculus for Extensibility and Reuse Elias Castegren Tobias Wrigstad KTH Royal Institute of Technology Uppsala University Kista, Sweden Uppsala, Sweden [email protected] [email protected] ABSTRACT This avoids tying the language to a specific model of class We present OOlong, an object calculus with interface in- inheritance (e.g., Java's), while still maintaining an object- heritance, structured concurrency and locks. The goal of oriented style of programming. Concurrency is modeled in a the calculus is extensibility and reuse. The semantics are finish/async style, and synchronisation is handled via locks. therefore available in a version for LATEX typesetting (written The semantics are provided both on paper and in a mecha- in Ott), a mechanised version for doing rigorous proofs in nised version written in Coq. The paper version of OOlong Coq, and a prototype interpreter (written in OCaml) for is defined in Ott [25], and all typing rules in this paper are typechecking an running OOlong programs. generated from this definition. To make it easy for other researchers to build on OOlong, we are making the sources of both versions of the semantics publicly available. We also CCS Concepts provide a prototype interpreter written in OCaml. •Theory of computation ! Operational semantics; Concur- rency; Interactive proof systems; •Software and its engineer- With the goal of extensibility and re-usability, we make the ing ! Object oriented languages; Concurrent programming following contributions: structures; Interpreters; • We define the formal semantics of OOlong, motivate the choice of features, and prove type soundness (Sections Keywords 2{5). Object Calculi; Semantics; Mechanisation; Concurrency • We provide a mechanised version of the full semantics and soundness proof, written in Coq (Section 6).
  • Proof-Relevant Π-Calculus

    Proof-Relevant Π-Calculus

    Proof-relevant π-calculus Roly Perera James Cheney University of Glasgow University of Edinburgh Glasgow, UK Edinburgh, UK [email protected] [email protected] Formalising the π-calculus is an illuminating test of the expressiveness of logical frameworks and mechanised metatheory systems, because of the presence of name binding, labelled transitions with name extrusion, bisimulation, and structural congruence. Formalisations have been undertaken in a variety of systems, primarily focusing on well-studied (and challenging) properties such as the theory of process bisimulation. We present a formalisation in Agda that instead explores the theory of concurrent transitions, residuation, and causal equivalence of traces, which has not previously been formalised for the π-calculus. Our formalisation employs de Bruijn indices and dependently- typed syntax, and aligns the “proved transitions” proposed by Boudol and Castellani in the context of CCS with the proof terms naturally present in Agda’s representation of the labelled transition relation. Our main contributions are proofs of the “diamond lemma” for residuation of concurrent transitions and a formal deVnition of equivalence of traces up to permutation of transitions. 1 Introduction The π-calculus [18, 19] is an expressive model of concurrent and mobile processes. It has been investigated extensively and many variations, extensions and reVnements have been proposed, including the asynchronous, polyadic, and applied π-calculus (among many others). The π-calculus has also attracted considerable attention from the logical frameworks and meta-languages community, and formalisations of its syntax and semantics have been performed using most of the extant mechanised metatheory techniques, including (among others) Coq [13, 12, 15], Nominal Isabelle [2], Abella [1] (building on Miller and Tiu [26]), CLF [6], and Agda [21].
  • A Time Constrained Real-Time Process Calculus

    A Time Constrained Real-Time Process Calculus

    2008:33 LICENTIATE T H E SIS A Time Constrained Real-Time Process Calculus Viktor Leijon Luleå University of Technology Department of Computer Science and Electrical Engineering EISLAB Universitetstryckeriet, Luleå 2008:33|: 02-757|: -c -- 08 ⁄33 -- A Time Constrained Real-Time Process Calculus Viktor Leijon EISLAB Dept. of Computer Science and Electrical Engineering Lule˚a University of Technology Lule˚a, Sweden Supervisor: Johan Nordlander Jingsen Chen ii The night is darkening round me, The wild winds coldly blow; But a tyrant spell has bound me And I cannot, cannot go. - Emily Bront¨e iv Abstract There are two important questions to ask regarding the correct execution of a real-time program: (i) Is there a platform such that the program executes correctly? (ii) Does the program execute correctly on a particular platform? The execution of a program is correct if all actions are taken within their exe- cution window, i.e. after their release time but before their deadline. A program which executes correctly on a specific platform is said to be feasible on that plat- form and an incorrect program is one which is not feasible on any platform. In this thesis we develop a timed process calculus, based on the π-calculus, which can help answer these questions. We express the time window in which computation is legal by use of two time restrictions, before and after, to express a deadline and a release time offset respectively. We choose to look at correctness through the traces of the program. The trace of a program will always be a sequence of interleaved internal reductions and time steps, because programs have no free names.
  • Université De Montréal Low-Impact Operating

    Université De Montréal Low-Impact Operating

    UNIVERSITE´ DE MONTREAL´ LOW-IMPACT OPERATING SYSTEM TRACING MATHIEU DESNOYERS DEPARTEMENT´ DE GENIE´ INFORMATIQUE ET GENIE´ LOGICIEL ECOLE´ POLYTECHNIQUE DE MONTREAL´ THESE` PRESENT´ EE´ EN VUE DE L’OBTENTION DU DIPLOMEˆ DE PHILOSOPHIÆ DOCTOR (Ph.D.) (GENIE´ INFORMATIQUE) DECEMBRE´ 2009 c Mathieu Desnoyers, 2009. UNIVERSITE´ DE MONTREAL´ ECOL´ E POLYTECHNIQUE DE MONTREAL´ Cette th`ese intitul´ee : LOW-IMPACT OPERATING SYSTEM TRACING pr´esent´ee par : DESNOYERS Mathieu en vue de l’obtention du diplˆome de : Philosophiæ Doctor a ´et´edˆument accept´ee par le jury constitu´ede : Mme. BOUCHENEB Hanifa, Doctorat, pr´esidente M. DAGENAIS Michel, Ph.D., membre et directeur de recherche M. BOYER Fran¸cois-Raymond, Ph.D., membre M. STUMM Michael, Ph.D., membre iii I dedicate this thesis to my family, to my friends, who help me keeping balance between the joy of sharing my work, my quest for knowledge and life. Je d´edie cette th`ese `ama famille, `ames amis, qui m’aident `aconserver l’´equilibre entre la joie de partager mon travail, ma quˆete de connaissance et la vie. iv Acknowledgements I would like to thank Michel Dagenais, my advisor, for believing in my poten- tial and letting me explore the field of operating systems since the beginning of my undergraduate studies. I would also like to thank my mentors, Robert Wisniewski from IBM Research and Martin Bligh, from Google, who have been guiding me through the internships I have done in the industry. I keep a good memory of these experiences and am honored to have worked with them. A special thanks to Paul E.
  • Systematic Use of Models of Concurrency in Executable Domain-Specific Modeling Languages Florent Latombe

    Systematic Use of Models of Concurrency in Executable Domain-Specific Modeling Languages Florent Latombe

    Systematic use of Models of Concurrency in eXecutable Domain-Specific Modeling Languages Florent Latombe To cite this version: Florent Latombe. Systematic use of Models of Concurrency in eXecutable Domain-Specific Modeling Languages. Software Engineering [cs.SE]. Université de Toulouse - Institut National Polytechnique de Toulouse (INPT), 2016. English. tel-01369451 HAL Id: tel-01369451 https://hal.inria.fr/tel-01369451 Submitted on 21 Sep 2016 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ÈSETHÈSE En vue de l’obtention du DOCTORAT DE L’UNIVERSITÉ DE TOULOUSE Délivré par : l’Institut National Polytechnique de Toulouse (INP Toulouse) Présentée et soutenue le 13/07/2016 par : Florent LATOMBE Systematic use of Models of Concurrency in eXecutable Domain-Specific Modeling Languages JURY Richard PAIGE Professor Rapporteur Antonio VALLECILLO Professor Rapporteur Frédéric BOULANGER Professeur des Universités Examinateur Julien DE ANTONI Maître de Conférences Examinateur Benoît COMBEMALE Maître de Conférences Invité Xavier CRÉGUT Maître de Conférences Encadrant Marc PANTEL Maître de Conférences Encadrant École doctorale et spécialité : MITT : Domaine STIC : Sureté de logiciel et calcul de haute performance Unité de Recherche : IRIT : Institut de Recherche en Informatique de Toulouse (UMR 5505) Directeur(s) de Thèse : Marc PANTEL, Xavier CRÉGUT et Yamine AÏT-AMEUR Rapporteurs : Richard PAIGE et Antonio VALLECILLO All that is gold does not glier, Not all those flho flander are lost; e old that is strong does not flither, Deep roots are not reached by the frost.