David Evans cs.virginia/~evans

David Evanshttp://www.cs.virginia.edu/~evans

CS655: Programming LanguagesUniversity of VirginiaComputer Science

Lecture 22: Abstractions for Concurrency

When you have a world-wide tuple space, you’ll be ableto 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 2001 CS 655: Lecture 21 2

Menu

• Form going around– Signup for Project Presentations– Vote for Next Lecture (no cheating!)

• Abstractions for Concurrency– Algol 68– Monitors– Linda and JavaSpaces


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.


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


Algol 68: Collateral Clauses

• Collateral Clausesstmt0; (stmt1, stmt2) stmt3;

Defines a partial order:

stmt0

stmt1 stmt2

stmt3


Algol 68: Semaphores

• Dijkstra, “Cooperating Sequential Processes”

• type semaup – increments

down – decrements (must > 0 before)


Semaphore Example

begin sema mutex := level 1;

proc producer

while not finished

do down mutex

... insert item

up mutex

od;


Semaphore Example, cont.proc consumer

while not finished

do down mutex

... remove item

up mutex

od;

par (producer, consumer)

// start them in parallel


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


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


Monitor Examplemonitor 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 appendExample adapted from [Hansen93]


Monitor Example, cont.

procedure remove () returns portion

if count = 0 then nonempty.wait;

x := ...

nonfull.signal

end remove;


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?


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?


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)


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


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!


TuplesConventional 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


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)


Meaning of taketake (“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


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


Shared AssignmentLoc := Expressiontake (“Loc”, formal loc_value);out (“Loc”, Expression);

e.g.:x := x + 1; take (“x”, formal x_value)

out (“x”, x_value + 1);


Semaphore

• Create (int n, String resource)for (i = 0; i < n; i++) out (resource);

• Down (String resource)take (resource)

• Up (String resource)out (resource)


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?


FactorialSetup:

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?


Finishing FactorialSetup:

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!


Concurrent Finishing FactorialSetup:

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);


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?)


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.


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

David Evans cs.virginia/~evans

Documents

Transcript of David Evans cs.virginia/~evans