The Implementation of the Cilk-5 Multithreaded Language by Matteo

Total Page:16

File Type:pdf, Size:1020Kb

The Implementation of the Cilk-5 Multithreaded Language by Matteo The Implementation of the Cilk Multithreaded Language Matteo Frigo Charles E Leiserson Keith H Randall MIT Lab oratory for Computer Science Technology Square Cambridge Massachusetts fathenacelrandallglcsmitedu Abstract our latest Cilk release still uses a theoretically ecient scheduler but the language has b een simplied considerably The fth release of the multithreaded language Cilk uses a It employs callreturn semantics for parallelism and features provably go o d workstealing scheduling algorithm similar a linguistically simple inlet mechanism for nondeterminis to the rst system but the language has b een completely re designed and the runtime system completely reengineered tic control Cilk is designed to run eciently on contem The eciency of the new implementation was aided by a p orary symmetric multipro cessors SMPs which feature clear strategy that arose from a theoretical analysis of the hardware supp ort for shared memory Wehave co ded many scheduling algorithm concentrate on minimizing overheads applications in Cilk including the So crates and Cilkchess that contribute to the work even at the exp ense of overheads chessplaying programs which have won prizes in interna that contribute to the critical path Although it mayseem counterintuitive to move overheads onto the critical path tional comp etitions this workrst principle has led to a p ortable Cilk im The philosophy behind Cilk development has been to plementation in which the typical cost of spawning a parallel make the Cilk language a true parallel extension of C b oth thread is only b etween and times the cost of a C function semantically and with resp ect to p erformance On a paral call on a variety of contemp orary machines Many Cilk pro lel computer Cilk control constructs allow the program to grams run on one pro cessor with virtually no degradation compared to equivalent C programs This pap er describ es execute in parallel If the Cilk keywords for parallel control how the workrst principle was exploited in the design of are elided from a Cilk program however a syntactically and Cilk s compiler and its runtime system In particular we semantically correct C program results whichwe call the C present Cilk s novel twoclone compilation strategy and elision or more generallytheserial elision of the Cilk its Dijkstralikemutualexclusion proto col for implementing program Cilk is a faithful extension of C b ecause the C the ready deque in the workstealing scheduler elision of a Cilk program is a correct implementation of the semantics of the program Moreover on one pro cessor a Keywords parallel Cilk program scales down to run nearly as fast as Critical path multithreading parallel computing program its C elision ming language runtime system work Unlike in Cilk where the Cilk scheduler was an identi able piece of co de in Cilk b oth the compiler and runtime Intro duction system b ear the resp onsibility for scheduling To obtain ef Cilk is a multithreaded language for parallel programming ciencywehave of course attempted to reduce scheduling that generalizes the semantics of C byintro ducing linguistic overheads Some overheads have a larger impact on execu constructs for parallel control The original Cilk release tion time than others however A theoretical understanding featured a provably ecient randomized work of Cilks scheduling algorithm has allowed us to iden stealing scheduler but the language was clumsy tify and optimize the common cases According to this ab b ecause parallelism was exp osed by hand using explicit stract theory the p erformance of a Cilk computation can b e continuation passing The Cilk language implemented by characterized bytwoquantities its work which is the to tal time needed to execute the computation serially and its This researchwas supp orted in part by the Defense Advanced criticalpath length which is its execution time on an in Research Pro jects Agency DARPA under Grant N Computing facilities were provided by the MIT Xolas Pro ject thanks nite numb er of pro cessors Cilk provides instrumentation to a generous equipment donation from Sun Microsystems that allows a user to measure these twoquantities Within Cilks scheduler we can identify a given cost as contribut To app ear in Proceedings of the ACM SIGPLAN ing to either work overhead or criticalpath overhead Much ConferenceonProgramming Language Design and Im plementation PLDI Montreal Canada June of the eciency of Cilk derives from the following principle whichwe shall justify in Section include stdlibh The workrst principle Minimize the schedul include stdioh ing overhead borne by the work of a computation include cilkh Specical ly move overheads out of the work and onto the critical path cilk int fib int n The workrst principle played an imp ortant role during the if n return n design of earlier Cilk systems but Cilk exploits the prin else int x y ciple more extensively x spawn fib n The workrst principle inspired a twoclone strategy y spawn fib n for compiling Cilk programs Our cilkc compiler is a sync return xy typ echecking sourcetosource translator that transforms a Cilk source into a C p ostsource which makes calls to Cilks runtime library The C p ostsource is then run through the cilk int main int argc char argv gcc compiler to pro duce ob ject co de The cilkc compiler pro duces two clones of every Cilk pro cedurea fast clone int n result and a slow clone The fast clone which is identical in n atoiargv result spawn fibn most resp ects to the C elision of the Cilk program executes sync in the common case where serial semantics suce The slow printf Result dn result clone is executed in the infrequent case that parallel seman return tics and its concomitant b o okkeeping are required All com munication due to scheduling o ccurs in the slow clone and contributes to criticalpath overhead but not to work over Figure A simple Cilk program to compute the nth Fib onacci numb er in parallel using a very bad algorithm head The workrst principle also inspired a Dijkstralike sharedmemory mutualexclusion proto col as part of the The basic Cilk language can b e understo o d from an exam runtime loadbalancing scheduler Cilks scheduler uses a ple Figure shows a Cilk program that computes the nth workstealing algorithm in which idle pro cessors called Fib onacci number Observe that the program would b e an thieves steal threads from busy pro cessors called vic ordinary C program if the three keywords cilk spawn and tims Cilks scheduler guarantees that the cost of steal sync are elided ing contributes only to criticalpath overhead and not to The keyword cilk identies fib as a Cilk procedure work overhead Nevertheless it is hard to avoid the mutual which is the parallel analog to a C function Parallelism exclusion costs incurred by a p otential victim which con is created when the keyword spawn precedes the invo cation tribute to work To minimize work overhead instead of using of a pro cedure The semantics of a spawn diers from a lo cking Cilks runtime system uses a Dijkstralike proto col C function call only in that the parent can continue to ex which we call the THE proto col to manage the runtime ecute in parallel with the child instead of waiting for the deque of ready threads in the workstealing algorithm An child to complete as is done in C Cilks scheduler takes the added advantage of the THE proto col is that it allows an resp onsibilityofscheduling the spawned pro cedures on the exception to b e signaled to a working pro cessor with no ad pro cessors of the parallel computer ditional work overhead a feature used in Cilks ab ort mech A Cilk pro cedure cannot safely use the values returned by anism its children until it executes a sync statement The sync The remainder of this pap er is organized as follows Sec statementisalocal barrier not a global one as for ex tion overviews the basic features of the Cilk language Sec ample is used in messagepassing programming In the Fi tion justies the workrst principle Section describ es b onacci example a sync statement is required before the how the twoclone strategy is implemented and Section statement return xy to avoid the anomaly that would presents the THE proto col Section gives empirical evi occur if x and y are summed b efore they are computed In dence that the Cilk scheduler is ecient Finally Section addition to explicit synchronization provided by the sync presents related work and oers some conclusions statement every Cilk pro cedure syncs implicitly b efore it returns thus ensuring that all of its children terminate b e The Cilk language fore it do es Ordinarily when a spawned pro cedure returns the re This section presents a brief overview of the Cilk extensions turned value is simply stored into a variable in its parents to C as supp orted by Cilk For a complete description frame consult the Cilk manual The key features of the lan This program uses an inecient algorithm which runs in exp onen guage are the sp ecication of parallelism and synchroniza tial time Although logarithmictime metho ds are known p tion through the spawn and sync keywords and the sp eci this program nevertheless provides a go o d didactic example cation of nondeterminism using inlet and abort cilk int fib int n ab out concurrency and nondeterminism without requiring lo cking declaration of critical regions and the like int x inlet void summer int result Cilk provides syntactic sugar to pro duce certain commonly used inlets implicitly For example the statement x x result spawn fibn conceptually
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]