Modularising Context Dependency and Group Behaviour in Ambient-Oriented Programming

Total Page:16

File Type:pdf, Size:1020Kb

Modularising Context Dependency and Group Behaviour in Ambient-Oriented Programming Faculteit van de Wetenschappen Vakgroep Computerwetenschappen Laboratorium voor Programmeerkunde Modularising Context Dependency and Group Behaviour in Ambient-oriented Programming Proefschrift ingediend met het oog op het behalen van de graad van Doctor in de Wetenschappen Jorge Vallejos Promotoren: Prof. Dr. Theo D’Hondt, Prof. Dr. Wolfgang De Meuter, Dr. Pascal Costanza Jul 2011 This work has been supported by the ICT Impulse Programme of the Institute for the encouragement of Scientific Research and Innovation of Brussels (INNOVIRIS), and by the Interuniversity Attraction Poles (IAP) Programme of the Belgian State, Belgian Science Policy. “Wie niet waagt, blijft maagd.” – Popular Belgian saying. iv Samenvatting In de visie van pervasive computing zijn computers ingebed in alledaagse apparaten. Zulke apparaten vormen onderling dynamische communicatienetwerken waarvan de topologie verandert naarmate de gebruikers zich verplaatsen. Van software services wordt verwacht dat ze maximaal gebruik maken van de beschikbare apparaten en dat de vereiste coör- dinatie transparant verloopt. Deze services moeten ook kunnen reageren op dynamische veranderingen in de omgeving zodat ze hun gedrag automatisch kunnen aanpassen. Een populaire aanpak om aan deze vereisten te voldoen bestaat erin om veranderingen in de omgeving voor te stellen als events, zodat pervasive computing applicaties gemodelleerd worden als event-gedreven systemen. Deze strategie heeft echter wel een impact op de on- derhoudbaarheid van pervasive computing programma’s. Hoe meer verschillende events een applicatie moet ondersteunen, hoe complexer het wordt om de control flow van het programma te beheren. Door een gebrek aan geschikte taalconstructies om events te ma- nipuleren, is het in het algemeen moeilijk om zulke programma’s te onderhouden en uit te breiden. In deze verhandeling bestuderen we de impact van event-gedreven distributie op de modulaire structuur van programma’s. We bestuderen twee bekommernissen in detail: Enerzijds bestuderen we de mogelijkheid van programma’s om zich aan te passen aan veranderingen in de omgeving—een eigenschap die bekend staat als contextafhankelijk gedrag—en anderzijds bestuderen we de capaciteit van programma’s om met elkaar te coördineren—een eigenschap die bekend staat als groepsafhankelijk gedrag. We baseren ons onderzoek op het ambient-georiënteerde programmeerparadigma (AmOP). Dit para- digma definieert een event-gedreven programmeermodel dat specifiek ontworpen is voor het pervasive computing domein. We identificeren een aantal vereisten voor het unifi- ceren van event-gestuurde distributie, contextafhankelijk gedrag, en groepsafhankelijk gedrag. In ons overzicht van de literatuur tonen we aan dat geen van de bestaande pro- grammeermodellen aan al deze vereisten voldoet. Dit leidde ons ertoe een experimentele programmeertaal te ontwikkelen voor pervasive computing, genaamd Lambic. Lambic is een uitbreiding van het op generische functies gebaseerde objectmodel van de programmeertaal Common Lisp. Ons model breidt de multiple dispatch semantiek van generische functies uit om een modulaire programmastructuur mogelijk te maken voor pervasive computing applicaties. Ter ondersteuning van event-gestuurde distributie, vervult Lambic de eigenschappen van het AmOP paradigma via een mechanisme dat we futurised generic functions noemen. Daarbovenop bieden we een nieuw mechanisme aan om de flexibele selectie en samenstelling van gedrag toe te laten. Dit mechanisme v vi noemen we predicated generic functions. Het laat ons toe om taalconstructies te definiëren zodat method dispatch de dynamische context van het programma in acht neemt. Ter ondersteuning van groepsafhankelijk gedrag, stellen we een derde uitbreiding voor, met name group generic functions. Het idee achter dit mechanisme is om de coördinatie van interacties tussen groepen in te kapselen in de definitie van services. Tot slot hebben we een gemeenschappelijk uitvoermodel gedefinieerd zodat de drie mechanismen effectief in combinatie met elkaar gebruikt kunnen worden. We valideren ons onderzoek door het bespreken van een aantal case studies die aantonen hoe Lambic het mogelijk maakt om vlot integreerbare en dynamisch aanpasbare pervasive computing services te ontwikkelen. Abstract The pervasive computing field envisions users surrounded by computers embedded in everyday devices. Such devices form dynamic networks which change topology as users move about. Software services are expected to maximise available computational capaci- ties by seamlessly coordinating with each other. The services should also react to dynamic changes in the environment and adapt their behaviour accordingly. An increasingly pop- ular solution to cope with such requirements is to represent environmental changes as events. Thus, pervasive computing software is often modelled as event-driven systems. However, such support typically comes at a price in the evolvability of programs. The more events a service has to be aware of, the more cumbersome its control flow becomes. The lack of adequate language abstractions to handle such events results in programs that are difficult to maintain and extend. In this work, we study the effects of event-driven distribution on the modularity of programs. We focus on the modularity of two concerns: the capacity of services to adapt to environmental changes —a property known as context-dependent behaviour— and their capacity to coordinate with each other —a property known as group behaviour. We use the ambient-oriented programming (AmOP) paradigm as the basis of our research. This paradigm proposes an event-driven programming model which has been designed specifically for pervasive computing. We identify a list of requirements for a unified model for event-driven distribution, context dependency and group behaviour. In the study of the state of the art we demonstrate that no single approach fulfils these requirements so far. This observation has led us to the definition of a proof-of-concept programming language model, called Lambic. Lambic is an extension of the generic function-based object system of the Common Lisp programming language. Our model extends the multiple dispatch semantics of generic functions to allow for modularity in pervasive computing. For event-driven distribution, Lambic integrates the properties of the AmOP paradigm, in what we call futurised generic functions. In addition, we provide a novel mechanism to allow flexible selection and composition of behaviour, called predicated generic functions. This mechanism provides language abstractions to influence method dispatch based on the program’s context. For group behaviour, we propose a third extension called group generic functions. The main idea of this feature is to encapsulate the coordination of group interactions in the definition of services. Finally, a common underlying execution process ensures that these three features can be effectively used in combination with one another. We validate our work by showing in a number of case studies how Lambic facilitates the natural integration and dynamic adaptation of pervasive computing services. vii viii Acknowledgements I would like to express my deepest gratitude to everyone who helped me to complete this dissertation. I would like to start thanking Theo D’Hondt and Wolfgang De Meuter for the in- valuable opportunity you gave me to do the PhD. Many thanks for your advice and encouragement throughout all these years. I would also like to thank Pascal Costanza for his guidance. Many thanks for always believing in my work, especially during the toughest periods. All my respect goes to you three! I would like to thank the members of the jury: Prof. Dave Clarke, Prof. Didier Verna, Prof. Viviane Jonckers, Prof. Beat Signer, Prof. Bernard Manderick and Prof. Luc Steels. Thanks for the time you invested reading my dissertation and for the questions and feedback during the private and public defences. Many thanks to all the members of the Software Languages Lab. I am especially indebted to my partners in crime: Peter Ebraert and Brecht Desmet for all the collab- orations at the early stage of my PhD, Elisa Gonzalez Boix for the many works we did together and for reviewing my dissertation, Tom Van Cutsem for those discussions which significantly influenced my research, and Engineer Bainomugisha for the endless but ex- tremely helpful brainstormings. Special thanks to Charlotte Herzeel for finding a name to my programming language model, and for translating the abstract of this dissertation to Dutch. Last but not least, thanks to Lydie Seghers, Brigitte Beyens and Simonne De Schrijver for their permanent support with the administrative matters. I also thank all the colleagues from other universities with whom I had the oppor- tunity to collaborate in the context of the Moves and Varibru projects. Special thanks to Boriss Mejías, Sebastián González, Éric Tanter, Alfredo Cádiz, Eddy Truyen, Frans Sanen, Andreas Classen, Arnaud Hubaux and Patrick Heymans. For the record: The hardest moments of writing the dissertation were when I thought that this was such a busy matter that I could not spend time in other activities. Totally nonsense. The fewer social activities I had, the worse I felt and less productive I became. I am deeply grateful towards my friends who, despite my stubbornness, still invited me to have a drink, to do sports, etc. Finally, I would like to thank my family. Many thanks to the great family Petitprez for the permanent support all these years. Thanks to my parents, Mary
Recommended publications
  • Benchmarking Implementations of Functional Languages with ‘Pseudoknot’, a Float-Intensive Benchmark
    Zurich Open Repository and Archive University of Zurich Main Library Strickhofstrasse 39 CH-8057 Zurich www.zora.uzh.ch Year: 1996 Benchmarking implementations of functional languages with ‘Pseudoknot’, a float-intensive benchmark Hartel, Pieter H ; Feeley, Marc ; et al Abstract: Over 25 implementations of different functional languages are benchmarked using the same program, a floating-point intensive application taken from molecular biology. The principal aspects studied are compile time and execution time for the various implementations that were benchmarked. An important consideration is how the program can be modified and tuned to obtain maximal performance on each language implementation. With few exceptions, the compilers take a significant amount of time to compile this program, though most compilers were faster than the then current GNU C compiler (GCC version 2.5.8). Compilers that generate C or Lisp are often slower than those that generate native code directly: the cost of compiling the intermediate form is normally a large fraction of the total compilation time. There is no clear distinction between the runtime performance of eager and lazy implementations when appropriate annotations are used: lazy implementations have clearly come of age when it comes to implementing largely strict applications, such as the Pseudoknot program. The speed of C can be approached by some implementations, but to achieve this performance, special measures such as strictness annotations are required by non-strict implementations. The benchmark results have to be interpreted with care. Firstly, a benchmark based on a single program cannot cover a wide spectrum of ‘typical’ applications. Secondly, the compilers vary in the kind and level of optimisations offered, so the effort required to obtain an optimal version of the program is similarly varied.
    [Show full text]
  • A Scheme Foreign Function Interface to Javascript Based on an Infix
    A Scheme Foreign Function Interface to JavaScript Based on an Infix Extension Marc-André Bélanger Marc Feeley Université de Montréal Université de Montréal Montréal, Québec, Canada Montréal, Québec, Canada [email protected] [email protected] ABSTRACT FFIs are notoriously implementation-dependent and code This paper presents a JavaScript Foreign Function Inter- using a given FFI is usually not portable. Consequently, face for a Scheme implementation hosted on JavaScript and the nature of FFI’s reflects a particular set of choices made supporting threads. In order to be as convenient as possible by the language’s implementers. This makes FFIs usually the foreign code is expressed using infix syntax, the type more difficult to learn than the base language, imposing conversions between Scheme and JavaScript are mostly im- implementation constraints to the programmer. In effect, plicit, and calls can both be done from Scheme to JavaScript proficiency in a particular FFI is often not a transferable and the other way around. Our approach takes advantage of skill. JavaScript’s dynamic nature and its support for asynchronous In general FFIs tightly couple the underlying low level functions. This allows concurrent activities to be expressed data representation to the higher level interface provided to in a direct style in Scheme using threads. The paper goes the programmer. This is especially true of FFIs for statically over the design and implementation of our approach in the typed languages such as C, where to construct the proper Gambit Scheme system. Examples are given to illustrate its interface code the FFI must know the type of all data passed use.
    [Show full text]
  • The Evolution of Lisp
    1 The Evolution of Lisp Guy L. Steele Jr. Richard P. Gabriel Thinking Machines Corporation Lucid, Inc. 245 First Street 707 Laurel Street Cambridge, Massachusetts 02142 Menlo Park, California 94025 Phone: (617) 234-2860 Phone: (415) 329-8400 FAX: (617) 243-4444 FAX: (415) 329-8480 E-mail: [email protected] E-mail: [email protected] Abstract Lisp is the world’s greatest programming language—or so its proponents think. The structure of Lisp makes it easy to extend the language or even to implement entirely new dialects without starting from scratch. Overall, the evolution of Lisp has been guided more by institutional rivalry, one-upsmanship, and the glee born of technical cleverness that is characteristic of the “hacker culture” than by sober assessments of technical requirements. Nevertheless this process has eventually produced both an industrial- strength programming language, messy but powerful, and a technically pure dialect, small but powerful, that is suitable for use by programming-language theoreticians. We pick up where McCarthy’s paper in the first HOPL conference left off. We trace the development chronologically from the era of the PDP-6, through the heyday of Interlisp and MacLisp, past the ascension and decline of special purpose Lisp machines, to the present era of standardization activities. We then examine the technical evolution of a few representative language features, including both some notable successes and some notable failures, that illuminate design issues that distinguish Lisp from other programming languages. We also discuss the use of Lisp as a laboratory for designing other programming languages. We conclude with some reflections on the forces that have driven the evolution of Lisp.
    [Show full text]
  • Tousimojarad, Ashkan (2016) GPRM: a High Performance Programming Framework for Manycore Processors. Phd Thesis
    Tousimojarad, Ashkan (2016) GPRM: a high performance programming framework for manycore processors. PhD thesis. http://theses.gla.ac.uk/7312/ Copyright and moral rights for this thesis are retained by the author A copy can be downloaded for personal non-commercial research or study This thesis cannot be reproduced or quoted extensively from without first obtaining permission in writing from the Author The content must not be changed in any way or sold commercially in any format or medium without the formal permission of the Author When referring to this work, full bibliographic details including the author, title, awarding institution and date of the thesis must be given Glasgow Theses Service http://theses.gla.ac.uk/ [email protected] GPRM: A HIGH PERFORMANCE PROGRAMMING FRAMEWORK FOR MANYCORE PROCESSORS ASHKAN TOUSIMOJARAD SUBMITTED IN FULFILMENT OF THE REQUIREMENTS FOR THE DEGREE OF Doctor of Philosophy SCHOOL OF COMPUTING SCIENCE COLLEGE OF SCIENCE AND ENGINEERING UNIVERSITY OF GLASGOW NOVEMBER 2015 c ASHKAN TOUSIMOJARAD Abstract Processors with large numbers of cores are becoming commonplace. In order to utilise the available resources in such systems, the programming paradigm has to move towards in- creased parallelism. However, increased parallelism does not necessarily lead to better per- formance. Parallel programming models have to provide not only flexible ways of defining parallel tasks, but also efficient methods to manage the created tasks. Moreover, in a general- purpose system, applications residing in the system compete for the shared resources. Thread and task scheduling in such a multiprogrammed multithreaded environment is a significant challenge. In this thesis, we introduce a new task-based parallel reduction model, called the Glasgow Parallel Reduction Machine (GPRM).
    [Show full text]
  • Part: an Asynchronous Parallel Abstraction for Speculative Pipeline Computations Kiko Fernandez-Reyes, Dave Clarke, Daniel Mccain
    ParT: An Asynchronous Parallel Abstraction for Speculative Pipeline Computations Kiko Fernandez-Reyes, Dave Clarke, Daniel Mccain To cite this version: Kiko Fernandez-Reyes, Dave Clarke, Daniel Mccain. ParT: An Asynchronous Parallel Abstraction for Speculative Pipeline Computations. 18th International Conference on Coordination Languages and Models (COORDINATION), Jun 2016, Heraklion, Greece. pp.101-120, 10.1007/978-3-319-39519- 7_7. hal-01631723 HAL Id: hal-01631723 https://hal.inria.fr/hal-01631723 Submitted on 9 Nov 2017 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. Distributed under a Creative Commons Attribution| 4.0 International License ParT: An Asynchronous Parallel Abstraction for Speculative Pipeline Computations? Kiko Fernandez-Reyes, Dave Clarke, and Daniel S. McCain Department of Information Technology Uppsala University, Uppsala, Sweden Abstract. The ubiquity of multicore computers has forced program- ming language designers to rethink how languages express parallelism and concurrency. This has resulted in new language constructs and new com- binations or revisions of existing constructs. In this line, we extended the programming languages Encore (actor-based), and Clojure (functional) with an asynchronous parallel abstraction called ParT, a data structure that can dually be seen as a collection of asynchronous values (integrat- ing with futures) or a handle to a parallel computation, plus a collection of combinators for manipulating the data structure.
    [Show full text]
  • The Butterfly(TM) Lisp System
    From: AAAI-86 Proceedings. Copyright ©1986, AAAI (www.aaai.org). All rights reserved. The Butterfly TMLisp System Seth A. Steinberg Don Allen Laura B agnall Curtis Scott Bolt, Beranek and Newman, Inc. 10 Moulton Street Cambridge, MA 02238 ABSTRACT Under DARPA sponsorship, BBN is developing a parallel symbolic programming environment for the Butterfly, based This paper describes the Common Lisp system that BBN is on an extended version of the Common Lisp language. The developing for its ButterflyTM multiprocessor. The BBN implementation of Butterfly Lisp is derived from C Scheme, ButterflyTM is a shared memory multiprocessor which may written at MIT by members of the Scheme Team.4 The contain up to 256 processor nodes. The system provides a simplicity and power of Scheme make it particularly suitable shared heap, parallel garbage collector, and window based as a testbed for exploring the issues of parallel execution, as I/Osystem. The future constructis used to specify well as a good implementation language for Common Lisp. parallelism. The MIT Multilisp work of Professor Robert Halstead and THE BUTTERFLYTM LISP SYSTEM students has had a significant influence on our approach. For example, the future construct, Butterfly Lisp’s primary For several decades, driven by industrial, military and mechanism for obtaining concurrency, was devised and first experimental demands, numeric algorithms have required implemented by the Multilisp group. Our experience porting increasing quantities of computational power. Symbolic MultiLisp to the Butterfly illuminated many of the problems algorithms were laboratory curiosities; widespread demand of developing a Lisp system that runs efficiently on both for symbolic computing power lagged until recently.
    [Show full text]
  • Graph Reduction Without Pointers
    Graph Reduction Without Pointers TR89-045 December, 1989 William Daniel Partain The University of North Carolina at Chapel Hill Department of Computer Science ! I CB#3175, Sitterson Hall Chapel Hill, NC 27599-3175 UNC is an Equal Opportunity/Aflirmative Action Institution. Graph Reduction Without Pointers by William Daniel Partain A dissertation submitted to the faculty of the University of North Carolina at Chapel Hill in partial fulfillment of the requirements for the degree of Doctor of Philosophy in the Department of Computer Science. Chapel Hill, 1989 Approved by: Jfn F. Prins, reader ~ ~<---(­ CJ)~ ~ ;=tfJ\ Donald F. Stanat, reader @1989 William D. Partain ALL RIGHTS RESERVED II WILLIAM DANIEL PARTAIN. Graph Reduction Without Pointers (Under the direction of Gyula A. Mag6.) Abstract Graph reduction is one way to overcome the exponential space blow-ups that simple normal-order evaluation of the lambda-calculus is likely to suf­ fer. The lambda-calculus underlies lazy functional programming languages, which offer hope for improved programmer productivity based on stronger mathematical underpinnings. Because functional languages seem well-suited to highly-parallel machine implementations, graph reduction is often chosen as the basis for these machines' designs. Inherent to graph reduction is a commonly-accessible store holding nodes referenced through "pointers," unique global identifiers; graph operations cannot guarantee that nodes directly connected in the graph will be in nearby store locations. This absence of locality is inimical to parallel computers, which prefer isolated pieces of hardware working on self-contained parts of a program. In this dissertation, I develop an alternate reduction system using "sus­ pensions" (delayed substitutions), with terms represented as trees and vari­ ables by their binding indices (de Bruijn numbers).
    [Show full text]
  • Parallelism in Lisp
    Parallelism in Lisp Michael van Biema Columbia University Dept. of Computer Science New York, N.Y. 10027 Tel: (212)280-2736 [email protected] three attempts are very interesting, in that two arc very similar Abstract in their approach but very different in the level of their constructs, and the third takes a very different approach. We This paper examines Lisp from the point of view of parallel do not study the so called "pure Lisp" approaches to computation. It attempts to identify exactly where the potential parallelizing Lisp since these are applicative approaches and for parallel execution really exists in LISP and what constructs do not present many of the more complex problems presented are useful in realizing that potential. Case studies of three by a Lisp with side-effects [4, 3]. attempts at augmenting Lisp with parallel constructs are examined and critiqued. The first two attempts concentrate on what we call control parallelism. Control parallelism is viewed here as a medium- or course-grained parallelism on the order of a function call in 1. Parallelism in Lisp Lisp or a procedure call in a traditional, procedure-oriented There are two main approaches to executing Lisp in parallel. language. A good example of this type of parallelism is the One is to use existing code and clever compiling methods to parallel evaluation of all the arguments to a function in Lisp, parallelize the execution of the code [9, 14, 11]. This or the remote procedure call or fork of a process in some approach is very attractive because it allows the use of already procedural language.
    [Show full text]
  • Parallel Combinators for the Encore Programming Language
    IT 16 007 Examensarbete 30 hp Februari 2016 Parallel Combinators for the Encore Programming Language Daniel Sean McCain Institutionen för informationsteknologi Department of Information Technology Abstract Parallel Combinators for the Encore Programming Language Daniel Sean McCain Teknisk- naturvetenskaplig fakultet UTH-enheten With the advent of the many-core architecture era, it will become increasingly important for Besöksadress: programmers to utilize all of the computational Ångströmlaboratoriet Lägerhyddsvägen 1 power provided by the hardware in order to Hus 4, Plan 0 improve the performance of their programs. Traditionally, programmers had to rely on low- Postadress: level, and possibly error-prone, constructs to Box 536 751 21 Uppsala ensure that parallel computations would be as efficient as possible. Since the parallel Telefon: programming paradigm is still a maturing 018 – 471 30 03 discipline, researchers have the opportunity to Telefax: explore innovative solutions to build tools and 018 – 471 30 00 languages that can easily exploit the computational cores in many-core architectures. Hemsida: http://www.teknat.uu.se/student Encore is an object-oriented programming language oriented to many-core computing and developed as part of the EU FP7 UpScale project. The inclusion of parallel combinators, a powerful high-level abstraction that provides implicit parallelism, into Encore would further help programmers parallelize their computations while minimizing errors. This thesis presents the theoretical framework that was built to provide Encore with parallel combinators, and includes the formalization of the core language and the implicit parallel tasks, as well as a proof of the soundness of this language extension and multiple suggestions to extend the core language.
    [Show full text]
  • Benchmarking Implementations of Functional Languages With
    Benchmarking Implementations of Functional Languages with Pseudoknot a FloatIntensive Benchmark Pieter H Hartel Marc Feeley Martin Alt Lennart Augustsson Peter Baumann Marcel Beemster Emmanuel Chailloux Christine H Flo o d Wolfgang Grieskamp John H G van Groningen Kevin Hammond Bogumil Hausman Melo dy Y Ivory Richard E Jones Jasp er Kamp erman Peter Lee Xavier Leroy Rafael D Lins Sandra Lo osemore Niklas Rojemo Manuel Serrano JeanPierre Talpin Jon Thackray Stephen Thomas Pum Walters Pierre Weis Peter Wentworth Abstract Over implementation s of dierent functional languages are b enchmarked using the same program a oating p ointintensive application taken from molecular biology The principal asp ects studied are compile time and Dept of Computer Systems Univ of Amsterdam Kruislaan SJ Amsterdam The Netherlands email pieterfwiuvanl Depart dinformatique et ro Univ de Montreal succursale centreville Montreal HC J Canada email feeleyiroumontrealca Informatik Universitat des Saarlandes Saarbruc ken Germany email altcsunisbde Dept of Computer Systems Chalmers Univ of Technology Goteb org Sweden email augustsscschalmersse Dept of Computer Science Univ of Zurich Winterthurerstr Zurich Switzerland email baumanniunizh ch Dept of Computer Systems Univ of Amsterdam Kruislaan SJ Amsterdam The Netherlands email b eemsterfwiuvanl LIENS URA du CNRS Ecole Normale Superieure rue dUlm PARIS Cedex France email EmmanuelChaillou xensfr Lab oratory for Computer Science MIT Technology Square Cambridge Massachusetts
    [Show full text]
  • Functional Programming 28 and 30 Sept
    Functional programming 28 and 30 Sept. 2020 ================================= Functional programming Functional languages such as Lisp/Scheme and ML/Haskell/OCaml/F# are an attempt to realize Church's lambda calculus in practical form as a programming language. The key idea: do everything by composing functions. No mutable state; no side effects. So how do you get anything done? --------------------------------- Recursion Takes the place of iteration. Some tasks are "naturally" recursive. Consider for example the function { a if a = b gcd(a, b) = { gcd(a-b, b) if a > b { gcd(a, b-a) if b > a (Euclid's algorithm). We might write this in C as int gcd(int a, int b) { /* assume a, b > 0 */ if (a == b) return a; else if (a > b) return gcd(a-b, b); else return gcd(a, b-a); } Other tasks we're used to thinking of as naturally iterative: typedef int (*int_func) (int); int summation(int_func f, int low, int high) { /* assume low <= high */ int total = 0; ___ int i; \ f(i) for (i = low; i <= high; i++) { /__ total += f(i); low ≤ i ≤ high } return total; } But there's nothing sacred about this "natural" intuition. Consider: int gcd(int a, int b) { /* assume a, b > 0 */ while (a != b) { if (a > b) a = a-b; else b = b-a; } return a; } typedef int (*int_func) (int); int summation(int_func f, int low, int high) { /* assume low <= high */ if (low == high) return f(low); else return f(low) + summation(f, low+1, high); } More significantly, the recursive solution doesn't have to be any more expensive than the iterative solution.
    [Show full text]
  • Part: an Asynchronous Parallel Abstraction for Speculative Pipeline Computations
    EasyChair Preprint № 43 ParT: An Asynchronous Parallel Abstraction for Speculative Pipeline Computations Kiko Fernandez-Reyes, Dave Clarke and Daniel S. McCain EasyChair preprints are intended for rapid dissemination of research results and are integrated with the rest of EasyChair. April 5, 2018 ParT: An Asynchronous Parallel Abstraction for Speculative Pipeline Computations? Kiko Fernandez-Reyes, Dave Clarke, and Daniel S. McCain Department of Information Technology Uppsala University, Uppsala, Sweden Abstract. The ubiquity of multicore computers has forced program- ming language designers to rethink how languages express parallelism and concurrency. This has resulted in new language constructs and new com- binations or revisions of existing constructs. In this line, we extended the programming languages Encore (actor-based), and Clojure (functional) with an asynchronous parallel abstraction called ParT, a data structure that can dually be seen as a collection of asynchronous values (integrat- ing with futures) or a handle to a parallel computation, plus a collection of combinators for manipulating the data structure. The combinators can express parallel pipelines and speculative parallelism. This paper presents a typed calculus capturing the essence of ParT, abstracting away from details of the Encore and Clojure programming languages. The calculus includes tasks, futures, and combinators similar to those of Orc but im- plemented in a non-blocking fashion. Furthermore, the calculus strongly mimics how ParT is implemented, and it can serve as the basis for adap- tation of ParT into different languages and for further extensions. 1 Introduction The ubiquity of multicore computers has forced programming language designers to rethink how languages express parallelism and concurrency. This has resulted in new language constructs that, for instance, increase the degree of asynchrony while exploiting parallelism.
    [Show full text]