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.
CS655: Programming Languages
David Evans
University of Virginia
http://www.cs.virginia.edu/~evans
Computer Science
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 2001
CS 655: Lecture 21
2
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 2001
CS 655: Lecture 21
3
Abstractions
• Programming at that low level would be
a pain – are there better abstractions?
– Hundreds of attempts...we’ll see a few
today.
• Issues
fork
– Thread creation
– Thread synchronization join
protect, acquire, release
– Resource contention
17 April 2001
CS 655: Lecture 21
4
Algol 68: Collateral Clauses
• Collateral Clauses
stmt0; (stmt1, stmt2) stmt3;
Defines a partial order:
stmt0
stmt1
stmt2
stmt3
17 April 2001
CS 655: Lecture 21
5
Algol 68: Semaphores
• Dijkstra, “Cooperating Sequential
Processes”
• type sema
up – increments
down – decrements (must > 0 before)
17 April 2001
CS 655: Lecture 21
6
Semaphore Example
begin sema mutex := level 1;
proc producer
while not finished
do down mutex
... insert item
up mutex
od;
17 April 2001
CS 655: Lecture 21
7
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 2001
CS 655: Lecture 21
8
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 2001
CS 655: Lecture 21
9
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 2001
CS 655: Lecture 21
10
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 2001
CS 655: Lecture 21
11
Monitor Example, cont.
procedure remove () returns portion
if count = 0 then nonempty.wait;
x := ...
nonfull.signal
end remove;
17 April 2001
CS 655: Lecture 21
12
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 2001
CS 655: Lecture 21
13
Synchronized Example
class ProducerConsumer {
private int x = 1;
synchronized void produce ()
{ x = x + 1; }
synchronized void consume ()
{ x = x – 1; }
}
17 April 2001
How could we require x stay positive?
CS 655: Lecture 21
14
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 2001
CS 655: Lecture 21
15
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 2001
CS 655: Lecture 21
16
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 2001
CS 655: Lecture 21
17
Tuples
Conventional
Memory
Linda/JavaSpaces
Unit
Bit
Logical Tuple
(23, “test”, false)
Access Using
Address (variable)
Selection of values
Operations
read, write
read, add, remove
JavaSpaces:
read, write, take
immutable
17 April 2001
CS 655: Lecture 21
18
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 2001
CS 655: Lecture 21
19
Meaning of take
take (“f”, int n)
Tuple Space
take (“f”, 23)
(“f”, 23)
take (“t”, bool b, int n)
(“t”, 25)
(“t”, true)
(“t”, false)
take (string s, int n)
(“f”, 17)
take (“cookie”)
17 April 2001
CS 655: Lecture 21
20
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 2001
CS 655: Lecture 21
21
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 2001
CS 655: Lecture 21
22
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 2001
CS 655: Lecture 21
23
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 2001
CS 655: Lecture 21
24
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);
What if last two elements are taken concurrently?
Eventually, tuple space contains one
entry which is the answer.
Better way to order Setup?
17 April 2001
CS 655: Lecture 21
25
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 2001
CS 655: Lecture 21
26
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 2001
CS 655: Lecture 21
27
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 2001
CS 655: Lecture 21
28
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 2001
CS 655: Lecture 21
29
Charge
• You can download JavaSpaces
implementation from:
http://java.sun.com/products/javaspaces/
• Project presentations for next week –
advice for them Thursday
• Projects are due 2 weeks from today
17 April 2001
CS 655: Lecture 21
30