David Evans CS655: Programming Languages University of Virginia Computer Science Lecture 22: Abstractions for Concurrency When you have a world-wide tuple space, you’ll be able to tune it in from any computer anywhere – or from any quasi-computer: any cell phone, any TV, any toaster. David Gelernter’s introduction to JavaSpaces Principles, Patterns, and Practice.

17 April 2001CS 655: Lecture 212 Menu Form going around –Signup for Project Presentations –Vote for Next Lecture (no cheating!) Abstractions for Concurrency –Algol 68 –Monitors –Linda and JavaSpaces

17 April 2001CS 655: Lecture 213 Last Time Concurrent programming is programming with partial ordering on time A concurrent programming language gives programmers mechanisms for expressing that partial order We can express many partial orders using the thread control primitives fork and join and locking primitives protect, acquire and release.

17 April 2001CS 655: Lecture 214 Abstractions Programming at that low level would be a pain – are there better abstractions? –Hundreds of attempts...we’ll see a few today. Issues –Thread creation –Thread synchronization –Resource contention fork join protect, acquire, release

17 April 2001CS 655: Lecture 215 Algol 68: Collateral Clauses Collateral Clauses stmt0; (stmt1, stmt2) stmt3; Defines a partial order: stmt0 stmt1stmt2 stmt3

17 April 2001CS 655: Lecture 216 Algol 68: Semaphores Dijkstra, “Cooperating Sequential Processes” type sema up – increments down – decrements (must > 0 before)

17 April 2001CS 655: Lecture 217 Semaphore Example begin sema mutex := level 1; proc producer while not finished do down mutex... insert item up mutex od;

17 April 2001CS 655: Lecture 218 Semaphore Example, cont. proc consumer while not finished do down mutex... remove item up mutex od; par (producer, consumer) // start them in parallel

17 April 2001CS 655: Lecture 219 What can go wrong? Programmer neglects to up semaphore Programmer neglects to down semaphore before accessing shared resource Programmer spends all her time worrying about up and down instead of the algorithm

17 April 2001CS 655: Lecture 2110 Monitors Concurrent Pascal [Hansen 74], Modula [Wirth 77], Mesa [Lampson80] Integrated data abstraction and resource synchronization Routines that use a shared resource grouped in a monitor, accesses only allowed through exported procedures Conditions can control when threads may execute exported procedures

17 April 2001CS 655: Lecture 2111 Monitor Example monitor boundedbuffer buffer: array 0..N-1 of int; count: 0..N; nonempty, nonfull: condition; procedure append (x: int) if count = N then nonfull.wait; buffer[count] := x; count := count + 1; nonempty.signal end append Example adapted from [Hansen93]

17 April 2001CS 655: Lecture 2112 Monitor Example, cont. procedure remove () returns portion if count = 0 then nonempty.wait; x :=... nonfull.signal end remove;

17 April 2001CS 655: Lecture 2113 Java Synchronization synchronized method qualifier –Once a synchronized method begins execution, it will complete before any other thread enters a method of the same object –Run-time must associate a lock with every object Is this enough to implement a semaphore? Is this better/worse than monitors?

17 April 2001CS 655: Lecture 2114 Synchronized Example class ProducerConsumer { private int x = 1; synchronized void produce () { x = x + 1; } synchronized void consume () { x = x – 1; } } How could we require x stay positive?

17 April 2001CS 655: Lecture 2115 Linda Program Concurrency by using uncoupled processes with shared data space Add concurrency into a sequential language by adding: –Simple operators –Runtime kernel (language-independent) –Preprocessor (or compiler)

17 April 2001CS 655: Lecture 2116 Design by Taking Away Backus: von Neumann bottleneck results from having a store –Remove the store  Functional Languages Gelernter: distributed programming is hard because of inter-process scheduling and communication due to order of mutation –We don’t have to remove the store, just mutation –Remove mutation  read-and-remove only store  tuple spaces

17 April 2001CS 655: Lecture 2117 Basic Idea Have a shared space (“tuple space”) –Processes can add, read, and take away values from this space Bag of processes, each looks for work it can do by matching values in the tuple space Get load balancing, synchronization, messaging, etc. for free!

17 April 2001CS 655: Lecture 2118 Tuples Conventional Memory Linda/JavaSpaces UnitBitLogical Tuple (23, “test”, false) Access UsingAddress (variable)Selection of values Operationsread, writeread, add, remove JavaSpaces: read, write, take immutable

17 April 2001CS 655: Lecture 2119 Tuple Space Operations out (t) – add tuple t to tuple space take (s)  t – returns and removes tuple t matching template s read (s)  t – same as in, except doesn’t remove t. Operations are atomic (even if space is distributed)

17 April 2001CS 655: Lecture 2120 Meaning of take take (“f”, int n) take (“f”, 23) take (“t”, bool b, int n) take (string s, int n) take (“cookie”) (“f”, 23) (“f”, 17) (“t”, 25) (“t”, true) (“t”, false) Tuple Space

17 April 2001CS 655: Lecture 2121 Operational Semantics Extend configurations with a tuple space (just a bag of tuples) Transition rule for out: –Just add an entry to the tuple space Transition rule for take: –If there is a match (ignoring binding): Remove it from the tuple space Advance the thread –Similar to join last time – it just waits if there is no match

17 April 2001CS 655: Lecture 2122 Shared Assignment Loc := Expression take (“Loc”, formal loc_value); out (“Loc”, Expression); e.g.: x := x + 1;  take (“x”, formal x_value) out (“x”, x_value + 1);

17 April 2001CS 655: Lecture 2123 Semaphore Create (int n, String resource) for (i = 0; i < n; i++) out (resource); Down (String resource) take (resource) Up (String resource) out (resource)

17 April 2001CS 655: Lecture 2124 Distributed Ebay Offer Item (String item, int minbid, int time): out (item, minbid, “owner”); sleep (time); take (item, formal bid, formal bidder); if (bidder  “owner”) SOLD! Bid (String bidder, String item, int bid): take (item, formal highbid, formal highbidder); if (bid > highbid) out (item, bid, bidder) else out (item, highbid, highbidder) How could a bidder cheat?

17 April 2001CS 655: Lecture 2125 Factorial Setup: for (int i = 1; i <= n; i++) out (i); start FactTask (replicated n-1 times) FactTask: take (int i); take (int j); out (i * j); Eventually, tuple space contains one entry which is the answer. Better way to order Setup? What if last two elements are taken concurrently?

17 April 2001CS 655: Lecture 2126 Finishing Factorial Setup: for (int i = 1; i <= n; i++) out (i); out (“workleft”, n - 1); take (“workleft”, 0); take (result); FactTask: take (“workleft”, formal w); if (w > 0) take (int i); take (int j); out (i * j); out (“workleft”, w – 1); endif; Opps – we’ve sequentialized it!

17 April 2001CS 655: Lecture 2127 Concurrent Finishing Factorial Setup: start FactWorker (replicated n-1 times) out (“done”, 0); for (int i = 1; i <= n; i++) { out (i); if i > 1 out (“work”); } take (“done”, n-1); take (result); FactWorker: take (“work”); take (formal int i); take (formal int j); out (i * j); take (“done”, formal int n); out (“done”, n + 1);

17 April 2001CS 655: Lecture 2128 Sorting in Linda Problem: Sorting an array of n integers Initial tuple state: (“A”, [A[0],..., A[n-1]]) Final tuple state: (“A”, [A’[0],..., A’[n-1]]) such A’ has a corresponding element for every element in A, and for all 0 <= j < k <= n-1, A’[j] <= A’[k]. Task: Devise a Linda sorting program and analyze its performance (can you match MergeSort?)

17 April 2001CS 655: Lecture 2129 Summary Linda/JavaSpaces provides a simple, but powerful model for distributed computing JavaSpaces extends Linda with: –Leases (tuples that expire after a time limit) Implementing an efficient, scalable tuple space (that provides the correct global semantics) is hard; people have designed custom hardware to do this.

17 April 2001CS 655: Lecture 2130 Charge You can download JavaSpaces implementation from: Project presentations for next week – advice for them Thursday Projects are due 2 weeks from today