David Evans cs.virginia/~evans

1. Lecture 20: Linda and JavaSpaces 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. David Evans http://www.cs.virginia.edu/~evans CS655: Programming Languages University of Virginia Computer Science

2. Menu • Manifest Today: on line only • Jinze’s Proof • Linda and JavaSpaces • Programming using Linda University of Virginia CS 655

3. 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) University of Virginia CS 655

4. 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 University of Virginia CS 655

5. 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! Warning: not a good strategy for managing your project team. University of Virginia CS 655

6. Tuples University of Virginia CS 655

7. 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) University of Virginia CS 655

8. Meaning of take Tuple Space take (“f”, int n) take (“f”, 23) take (“t”, bool b, int n) take (string s, int n) take (“cookie”) (“f”, 23) (“t”, 25) (“t”, true) (“t”, false) (“f”, 17) University of Virginia CS 655

9. 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 University of Virginia CS 655

10. 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); University of Virginia CS 655

11. Semaphore • Create (int n, String resource) for (i = 0; i < n; i++) out (resource); • Down (String resource) take (resource) • Up (String resource) out (resource) University of Virginia CS 655

12. Distributed Ebay • Offer Item (String item, int minbid, int timeout): out (item, minbid, “owner”); sleep (timeout); 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) University of Virginia CS 655

13. 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. What is last two elements are taken concurrently? Better way to order Setup? University of Virginia CS 655

14. 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! University of Virginia CS 655

15. 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); University of Virginia CS 655

16. 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]. • In your project groups: devise a Linda sorting program and analyze its performance (can you match MergeSort?) University of Virginia CS 655

17. 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. University of Virginia CS 655

18. Charge • You can download JavaSpaces implementation from: http://java.sun.com/products/javaspaces/ • Next time: Aspect-Oriented Programming • Abstract out things that cross-cut objects or procedures • Projects are due 2 weeks from tomorrow University of Virginia CS 655