DOCSLIB.ORG

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

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
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. From the ashes a re shall be floken, A light from the shadofls shall spring; Renefled shall be blade that flas broken, e croflnless again shall be king. in e Fellowship of the Ring, by J. R. R. Tolkien (1892 – 1973). Acknoflledgements is too short of a section is dedicated to my acknoflledging of all the people flho hafie shared their effiperience, mentorship, friendship, kindness and lofie flith me dffring these past fefl years. I can’t thank enoffgh my sffperfiisors Marc Pantel and Xafiier Crégfft for gifiing me the opportffnity to do a PhD ffnder their gffidance. anks for trffsting me. I also flant to thank all the actifie members of the ANR INS Project GEMOC flhose inffence on this thesis I can nefier come close to qffantify correctly. anks for all the discffssions and adfiices yoff hafie gifien me. I can’t skip ofier thanking all the people I hafie met flhile florking at IRIT ; researchers, secretaries, and fellofl doctoral stffdents alike. I flant to thank the sffperfiisors dffring my stay at the National Institffte of Informatics in Tokyo, Soichiro Hidaka and Zhenjiang Hff. I hafie learned a lot from yoff ofier too short a time. I floffld like to thank my family for sffpporting me and for not making me hafie to effiplain the topic of my PhD too many times. anks to all my friends in Toffloffse and elseflhere for sticking aroffnd. I apologize if I hafie encoffraged any of yoff to start yoffr ofln PhD. Finally, ’anks’ floffld not efien begin to cofier my gratitffde for the sffpport I get at home. Tusen tack! is thesis has been redacted using the TeXstudio editor1. e template used is a modication of Krishna Kumar’s thesis template for the Cambridge University Engineering Department2. 1http://flflfl.teffistffdio.org/ 2https://githffb.com/kks32/phd-thesis-template Abstract e compleffiity of modern soflares and systems, like the Internet of ings or Cyber- Physical Systems, has been increasing regfflarly since the birth of compffting. ey inte- grate many featffres, possibly relying on a fiariety of netflorks or other systems; comply to dierent norms, inclffding secffrity and safety standards; all the flhile reacting in a timely manner. eir design and defielopment is costly, both in the reqffired engineering eort, and possibly also in terms of their rafl physical parts. eir ffpdating and maintenance processes are also compleffi to handle. To ease these actifiities, researchers in soflare en- gineering hafie proposed nefl defielopment paradigms. In this conteffit, Language-Oriented Programming (LOP) proposes to make langffages rst-class citizens in the soflare en- gineering actifiities. LOP adfiocates ffsing mffltiple Domain-Specic Langffages (DSLs), each specialized for a particfflar problem domain. Since modern systems are ffsffally de- signed by domain effiperts, the ffse of Domain-Specic Modeling Langffages (DSMLs) is gaining traction, becaffse their abstractions are designed to be intffitifie for the end ffsers, i.e., the domain effiperts. is has led to the defielopment of a nefl discipline called Soware Language Engineering, flhich stffdies the design, implementation and tooling of Domain- Specic (Modeling) Langffages. To facilitate the early fierication and fialidation actifiities of these systems, DSMLs can be made eXecfftable (ffiDSMLs). In the conteffit of Model- Drifien Engineering (MDE), the design of ffiDSMLs has led to the defielopment of sefieral “Effiecfftable Metamodeling” approaches, flhere models are effiecfftable according to an effi- ecfftion semantics dened at the metamodel (abstract syntaffi) lefiel. Modern soflares and systems are also increasingly concffrrent, to accommodate for their increasing scale in ffsers, featffres, and ofierall importance in offr societies. To en- sffre an adeqffate behafiior, notably in terms of their interfacing flith ffsers or flith other systems, or simply in terms of performance, their effiecfftion enfiironments profiide more and more parallel facilities, sffch as GPGPU pipelines, many-core CPUs or FPGAs. To facilitate their deployment on fiarioffs platforms, highly-concffrrent soflares mffst be de- fieloped flithofft prior knoflledge of their effiecfftion platforms, flhile still allofling fffll effiploitation of the afiailable parallel facilities at rffntime. e specication of the concffr- viii rency concerns of modern systems is thffs placed at the heart of the soflare engineering actifiities. eoretical compffter science has stffdied sefieral paradigms for this pffrpose, commonly denominated as Models of Concffrrency (MoCs). MoCs are formalisms flhich are practical for the analytical stffdy of properties relating to concffrrency, sffch as detect- ing deadlocks, starfiation sitffations or lifieness properties of critical parts of a system. Bfft ffsing a MoC is compleffi, since it reqffires both theoretical knoflledge abofft the MoC, prac- tical knoflledge abofft its ffse, and ofierall solid knoflledge of the system being defieloped. Efien if effiplicitly ffsed, it is essentially hard-coded for a specic system, and lile to no gffarantee of its correct ffse is ensffred by the langffage. We bffild ffpon an effiisting ffiDSML design approach, pffblished in the International Con- ference on Soflare Langffage Engineering 2012 [18] and 2013 [19], flhich aempts to bridge the gap betfleen LOP and MoCs, by designing so-called Concurrency-aware xDSMLs. In these langffages, the concffrrency concerns of an ffiDSML are made effiplicit ffsing a dedi- cated formalism based on a MoC. By making these concerns effiplicit at the langffage lefiel, the correct ffse of a MoC for any program conforming to the syntaffi of the langffage is ensffred. ey can be specialized at design time, to implement a particfflar Semanptic Variation Point (SVP) of the langffage, or rened at deployment time, for a specic effie- cfftion platform. Conseqffently, the concffrrency aspects of a system can be analyzed, fiia model-checking tools for instance. In this thesis, fle detail and improfie ffpon the design of concffrrency-aflare ffiDSMLs. We rst focffs on the separation of concerns inside the operational semantics specication. e concffrrency concerns are separated from the data and fffnctional operations aspects of the semantics. Effiecffting a model is done by coordinating the effiecfftion of these tflo concerns. is coordination is specied thanks to a third concern, making effiplicit the com- mffnication betfleen the rst tflo concerns. We stffdy the possible coordinations that can be specied, and hofl they are realized at rffntime. en, fle focffs on the Model of Concffr- rency ffsed in the initial approach: Efient Strffctffres. is formalism is not a good t for all ffiDSMLs, thffs fle propose a recffrsifie denition of concffrrency-aflare ffiDSMLs, enabling the ffse of any concffrrency-aflare ffiDSML as a MoC. is approach profiides a formal def- inition and interface for MoCs, as flell as allofls ffiDSMLs to ffse an adapted langffage for the specication of their concffrrency. Finally, fle step aflay from operational semantics and propose an approach to dene the semantics of concffrrency-aflare ffiDSMLs in a trans- lational manner, based on any prefiioffsly-dened concffrrency-aflare ffiDSML. We detail the adfiantages and draflbacks of ffsing translational semantics instead of operational se- mantics in the conteffit of concffrrency-aflare ffiDSMLs, and propose an approach to catch ffp on some of the effiecfftion facilities profiided by the operational semantics approach. À l’aention des lecteffrs francophones To the French-speaking Readers Conformément à l’Article L121-3 dff Code de l’Édffcation3 ; à la décision dff Conseil Sci- entiqffe de l’Unifiersité Toffloffse III Paffl Sabatier4 ; et affffi directifies de l’École Doctorale 475 Mathématiqffes, Informatiqffe et Télécommffnications de Toffloffse5 ; cee thèse est rédigée en langffage
Load more
Loading...
Loading...
Loading...
Loading...
Loading...

350 pages remaining, click to load more.

Recommended publications
  • 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
    [Show full text]
  • 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.
    [Show full text]
  • 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 eliasca@kth.se tobias.wrigstad@it.uu.se 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).
    [Show full text]
  • The State of Fibers for the JVM Why All Your JVM Coroutines Are Cool, but Broken, and Project Loom Is Gonna Fix That! Lightweigh
    The State of Fibers for the JVM Lightweight Threads Virtual and ... Why all your JVM coroutines are cool, but broken, (Kilim threads, Quasar fibers, Kotlin coroutines, etc.) and Project Loom is gonna fix that! Volkan Yazıcı https://vlkan.com 2019-12-10 @yazicivo 2018-08-25 2018-03-08 Agenda 1) Motivation 2) History 3) Continuations 4) Processes, threads, and fibers 5) Project Loom 6) Structured concurrency 7) Scoped variables Motivation: I/O Quoting from Gor Nishanov's 2016 "LLVM Coroutines: Bringing resumable functions to LLVM" talk. Without I/O, you don’t exist! ● println() ● file access ● network socket access ● database access ● etc. In 1958, ... Quoting from Gor Nishanov's 2016 "LLVM Coroutines: Bringing resumable functions to LLVM" talk. The legend of Melvin Conway Quoting from Gor Nishanov's 2016 "LLVM Coroutines: Bringing resumable functions to LLVM" talk. Subroutine ⊂ Coroutine Coroutine Subroutine A Subroutine B Subroutine A Coroutine C “Coroutines” – Melvin Conway, 1958 … … B start C start call B “Generalization of subroutine” – Donald Knuth, 1968 call C end suspend subroutines coroutines B start resume C allocate frame, allocate frame, suspend call call B pass params pass params free frame, free frame, return resume C return result return result end end suspend No Yes … resume No Yes … Quoting from Gor Nishanov's 2016 "LLVM Coroutines: Bringing resumable functions to LLVM" talk. Where did all the coroutines go? Algol-60 … introduced code blocks and the begin and end pairs for delimiting them. ALGOL 60 was the first language implementing nested function definitions with lexical scope. – Wikipedia “ALGOL 60” Quoting from Gor Nishanov's 2016 "LLVM Coroutines: Bringing resumable functions to LLVM" talk.
    [Show full text]
  • Revisiting Coroutines
    6 Revisiting Coroutines ANA LUCIA´ DE MOURA and ROBERTO IERUSALIMSCHY Catholic University of Rio de Janeiro (PUC–Rio) This article advocates the revival of coroutines as a convenient general control abstraction. After proposing a new classification of coroutines, we introduce the concept of full asymmetric coroutines and provide a precise definition for it through an operational semantics. We then demonstrate that full coroutines have an expressive power equivalent to one-shot continuations and one-shot delimited continuations. We also show that full asymmetric coroutines and one-shot delimited continuations have many similarities, and therefore present comparable benefits. Nevertheless, coroutines are easier implemented and understood, especially in the realm of procedural languages. Categories and Subject Descriptors: D.3.3 [Programming Languages]: Language Constructs and Features—Control structures, coroutines General Terms: Design, Languages Additional Key Words and Phrases: Continuations, generators, multitasking ACM Reference Format: de Moura, A. L. and Ierusalimschy, R. 2009. Revisiting coroutines. ACM Trans. Program. Lang. Syst. 31, 2, Article 6 (February 2009), 31 pages. DOI = 10.1145/1462166.1462167 http:// doi.acm.org/10.1145/1462166.1462167 1. INTRODUCTION The concept of coroutines was introduced in the early 1960’s and constitutes one of the oldest proposals of a general control abstraction. It is attributed to Conway, who described coroutines as “subroutines who act as the master pro- gram,” and implemented this construct to
    [Show full text]
  • Concurrency Roadmap Misc Interoperability with Objective-C
    Goal: make concurrent programs simpler to reason about and safer (no data races) Data race = two threads access the same data Data races in memory concurrently (at least one writer) Increasing the priority of a task The mechanism to prevent data can automatically increase the Because the child tasks are races proactively priority of the child tasks known Data isolation Actor-local data, and each actor is single- When a higher-priority task waits on threaded (or serial-queued) internally a lower-priority task, the priority of all child tasks can be escalated An actor performs local computation on its own private state This is the timeout problem Nathaniel Smith wrote about in In the form of calling async Examples of systemic Limiting the total time spent on a his blog posts on structured instance methods task management task (including its child tasks) concurrency "by only allowing asynchronous instance problems this can solve Cancelling a task also cancels Actors send messages methods of actor classes to be invoked from "This eliminates the need for any queuing or its child tasks to other actors outside the actor, we ensure that all synchronization within the synchronous Semantics synchronous methods are already inside the code, making such code more efficient and Structured concurrency = concurrent "Task-local storage" can be actor when they are called" simpler to write" programs are organized into tasks and picked up by child tasks child tasks rather than simply a sea of Messages can't be sync It's possible this restriction could be lifted under formally-unrelated threads and jobs Child tasks can communicate up certain circumstances, e.g.
    [Show full text]
  • Java Concurrency Evolution It Is Becoming Crucial to Understand the Tooling Around How the Available Computing Capacity Can Be Best Utilized
    Java Concurrency Evolution It is becoming crucial to understand the tooling around how the available computing capacity can be best utilized. by Csaba Bejan · Dec. 02, 20 · Java Zone · Opinion Since the early days of Java, Threads were available to support concurrent programming. Interestingly till Java 1.1, green threads (virtual threads) were supported by the JVM, but they were dropped in favor of native OS threads, however with Project Loom on the horizon (targeted for Java 16 or later?), virtual threads are on track to become mainstream again. The goal of this article is to go through the main milestones for the evolution of thread/concurrency handling in Java. As the topic can easily fill a library full of books, the following aspects are out of scope (basically, the goal is to take a look at the happy path of Java concurrency): Error handling – This is very limited, to say the least. Lombok’s SneakyThrows is used to support readability in the code examples. Libraries and Frameworks supporting concurrency – There are endless alternative solutions for the JVM (e.g., Quasar, Akka, Guava, EA Async…) Sophisticated stop conditions – When kicking off a thread with a given task, it is not always clear how and how long to wait for its completion Synchronization between threads – The literature is endless about this. So, what will we covering here, you may ask? A very valid question as it may seem that we excluded all the fun stuff. We will take an example task which we will solve multiple times using newer / different approaches, and we will compare their execution ”behavior.” By nature, this list can’t be complete.
    [Show full text]
  • A Runtime Verification Framework for Kotlin Mobile Applications
    A Runtime Verification Framework For Kotlin Mobile Applications Master’s thesis in Computer science and engineering Denis Furian Department of Computer Science and Engineering CHALMERS UNIVERSITY OF TECHNOLOGY UNIVERSITY OF GOTHENBURG Gothenburg, Sweden 2020 Master’s thesis 2020 A Runtime Verification Framework For Kotlin Mobile Applications Denis Furian Department of Computer Science and Engineering Chalmers University of Technology University of Gothenburg Gothenburg, Sweden 2020 A Runtime Verification Framework For Kotlin Mobile Applications Denis Furian © Denis Furian, 2020. Supervisor: Gerardo Schneider, Department of Computer Science and Engineering Industrial Advisor: Boris Tiutin, Opera Software AB External Advisors: Christian Colombo, University of Malta Yliès Falcone, University Grenoble Alps Examiner: Wolfgang Ahrendt, Department of Computer Science and Engineering Master’s Thesis 2020 Department of Computer Science and Engineering Chalmers University of Technology and University of Gothenburg SE-412 96 Gothenburg Telephone +46 31 772 1000 Typeset in LATEX Gothenburg, Sweden 2020 iv A Runtime Verification Framework For Kotlin Mobile Applications Denis Furian Department of Computer Science and Engineering Chalmers University of Technology and University of Gothenburg Abstract The Kotlin programming language has recently been introduced to Android as the recommended language for development. We investigated whether we could use this language to improve the state of the art for Runtime Verification on mobile devices and focused on creating an API to monitor the execution of coroutines, one of the main Kotlin functionalities that are not featured in Java. This API should be employed by Android programmers to carry out concurrent tasks in a monitored environment and verify at runtime that the Kotlin guidelines and best practices for coroutines are being followed.
    [Show full text]
  • Copyright by David Wilson Kitchin 2013
    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.
    [Show full text]
  • Kotlin Coroutines for Android
    GDG Android Athens Meetup 2019/02/27 An introduction to Kotlin Coroutines for Android Antonis Lilis, Mobile Engineer The Problem How to prevent our applications from blocking ● Asynchronous or non-blocking programming is the new reality ○ Fluid client experience ○ Scalable server architecture Approaches ● Threads ○ hard to write and maintain ● Callbacks ○ series of nested callbacks which lead to incomprehensible code ● Futures, Promises,... ○ different programming mental model ● Reactive Extensions ○ everything is a stream, and it's observable ● Coroutines Coroutines ● Based on the concept of suspending functions ● The code is still structured as if we were writing synchronous code ● Are like light-weight threads ● Jetbrains engineers took the best ideas from other languages like Python, Go, C# and JS The term 'Coroutine' was coined by Melvin Conway in 1958 (known for Conway's Law) Kotlin Coroutines ● Kotlin provides Coroutine support at the language level ○ Actually it only adds one language keyword (suspend) ● Functionality is delegated to libraries ○ kotlinx.coroutines is a library developed by JetBrains ● Since Kotlin 1.3 Coroutines are no longer experimental ○ The major feature of this release Suspending Functions - Continuations Synchronous - Sequential Code Asynchronous - Concurrent Code The structure did not change much Coroutines are light-weight Suspending Functions (sequential code example) Suspending Functions ● Used inside coroutines ● They can call other ● Waits tasks like regular functions suspending functions to complete
    [Show full text]
  • Verifying Concurrent Programs by Controlling Alias Interference
    c Copyright 2014 Colin S. Gordon Verifying Concurrent Programs by Controlling Alias Interference Colin S. Gordon A dissertation submitted in partial fulfillment of the requirements for the degree of Doctor of Philosophy University of Washington 2014 Reading Committee: Michael D. Ernst, Chair Dan Grossman, Chair Matthew Parkinson, Microsoft Research, Cambridge, UK Program Authorized to Offer Degree: UW Computer Science and Engineering University of Washington Abstract Verifying Concurrent Programs by Controlling Alias Interference Colin S. Gordon Co-Chairs of the Supervisory Committee: Professor Michael D. Ernst Computer Science and Engineering Associate Professor Dan Grossman Computer Science and Engineering This dissertation proposes a family of techniques for static verification of sequential and concurrent imperative programs by leveraging fine-grained characterizations of mutation. The key idea is that by attaching to each reference in a program (1) a restriction on mu- tations permitted using that reference, and (2) a characterization of possible interference through other aliases, a type system can reason about what properties are preserved by all mutations in a program. This thesis develops four variations on this idea: (1) We adapt reference immutability to support data-race-free concurrent programming. (2) We generalize reference immutability to rely-guarantee references, allowing two-state invariants to express usage restrictions be- tween read-only and arbitrary mutation. (3) We extend rely-guarantee references to prove invariants and functional correctness of lock-free concurrent data structures. (4) We evalu- ate rely-guarantee references' utility for existing Haskell programs. Together these variations show that reasoning about aliasing and reasoning about con- current (imperative) programs are the same fundamental challenge, and that by taking the right foundational approach to reasoning about sequential programs, the gap to reasoning about concurrent programs is significantly reduced.
    [Show full text]
  • Server-Side Kotlin Coroutines
    Server-side Kotlin with Coroutines Roman Elizarov relizarov Speaker: Roman Elizarov • Professional developer since 2000 • Previously developed high-perf trading software @ Devexperts • Teach concurrent & distributed programming @ St. Petersburg ITMO University • Chief judge @ Northern Eurasia Contest / ICPC • Now team lead in Kotlin Libraries @ JetBrains elizarov @ relizarov Kotlin – Programming Language for Kotlin – Programming Language for Server-side This talk Backend evolution Starting with “good old days” Old-school client-server monolith Executor Threads ET 1 ET 2 Clients DB … ET N Incoming request Executor Threads ET 1 ET 2 Clients DB … ET N Blocks tread Executor Threads ET 1! ET 2 Clients DB … ET N Sizing threads – easy Executor Threads ET 1 ET 2 Clients DB … ET N N = number of DB connections Services Old-school client-server monolith Executor Threads ET 1 ET 2 Clients DB … ET N Now with Services Executor Threads ET 1 DB ET 2 Clients … ET N Service Services everywhere Executor Threads ET 1 Service 1 ET 2 Service 2 Clients … … ET N Service K Sizing threads – not easy Executor Threads ET 1 Service 1 ET 2 Service 2 Clients … … ET N Service K N = ????? Complex business logic fun placeOrder(order: Order): Response { … } Complex business logic fun placeOrder(order: Order): Response { val account = accountService.loadAccout(order.accountId) … } Complex business logic fun placeOrder(order: Order): Response { val account = accountService.loadAccout(order.accountId) val margin = if (account.isOptionsAccount) … } Complex business logic fun
    [Show full text]