1. 1 Contents Distributed data structures Different implementations First example: bank transactions JavaSpaces concepts Replicated-worker pattern Second example: Mandelbrot set

2. 2 Distributed data structures “A distributed data structure is a data structure that can be accessed and manipulated by multiple processes at the same time” In most distributed systems are hard to achieve Message passing (CORBA) or RMI (remote method invocation) in Java are good examples

3. 3 Ordinary systems Ordinary systems tend to barricade data structures behind one central manager Attempting to parallelize across more than one machine faces to a bottleneck Multiple processes can’t access the data in a concurrently way

4. 4 JavaSpace solution JavaSpaces solve this problem with a different approach Data structures are represented as collection of objects than can be independently accessed in a concurrent manner Processes no longer wait in line

5. 5 First example Bank transactions Two bank tellers are making a deposit to the same bank account at the same time. A deposit consist in 3 different operations –Looking up –Modifying –Setting the account’s value

6. 6 First example Problems arise in this scenario: –The bank account value is $200 –The two Bank tellers want to deposit respectively $100 and $50 –Bank teller #1 looks up the balance of $200 –Bank teller #2 looks up the balance and reads $200 too, since bank teller #1 hasn’t completed the deposit yet –Bank teller #1 performs the deposit and records a balance of $300 –Bank teller #2 performs the deposit and records a balance of $250

7. 7 First example The bank account has been corrupted The problem occurs because updating the bank balance is not an atomic operation To solve the problem updating a shared value needs to be an atomic operation With JavaSpaces we get this atomicity “for free”

8. 8 First Example Pseudocode for the bank transaction SharedVar template = new SharedVar(“bank account”); SharedVar result = (SharedVar) space.take(template, null, Long.MAX_VALUE); result.value = new Integer(result.value.intValue() + 100); space.write(result, null, Lease.FOREVER); The race condition can’t occur here, since only one process can “own” the bank account at the same time

9. 9 First Example Isn’t production ready yet What append if one bank teller removes the Entry that describes the bank account and fails to return it for a program crash or a network down? Luckily there are several ways to improve our code. We’ll see that topics later…

10. 10 JavaSpace concepts Topics that especially shine in JavaSpaces Processes involved in the computation no longer wait in line, they can work on independent pieces of data at the same time, as long as they don’t “step on each others toes” Every program written having JavaSpaces in mind should implement this concept tightly

11. 11 JavaSpaces concepts The program data has to be broken in several (and smaller) pieces, allowing two or more processes to use the program data simultaneously

12. 12 JavaSpace concepts: example Imagine now that two process are accessing the same array at two different locations at the same time There are two different way to do this in JavaSpaces The first is the „classic“ implementation The second is „JavaSpaces-approved“ and improves the parallelization

13. 13 JavaSpace concepts: 1 code Pseudocode public class array1 implements Entry { public int data[]; public array1() {}; } The array is defined as a “continuous” memory area Only one process can “own” the array-Entry at the same time

14. 14 JavaSpace concepts: 1 code The first process grabs the array, works with it and puts it back The second process can begin to work only after the end of the first process, even if they were interested in different pieces of data

15. 15 JavaSpaces concepts: 2 code Pseudocode public class array2 implements Entry { public int data; public int offset; public array2() {} } The array is composed of several integer-Entries

16. 16 JavaSpaces concepts: 2 code The two process work on different pieces of data at the same time The tasks don’t wait for a resource that can be shared

17. 17 Replicated-worker pattern This pattern is designed to solve intensive computation problems in terms of smaller tasks that can be computed concurrently This pattern involves –one Master, along with –any number of workers

18. 18 Replicated-worker pattern The Master takes a problem, divides it up into smaller tasks and deposit them into the space The workers spend their lives waiting for tasks, removing them from the space, computing them and writing the results back into the space The Master collects then the tasks’ results and combine them into a meaningful overall solution

19. 19 Replicated-worker pattern Pseudocode for the Master: public class Master { for (int i = 0; i < totalTasks; i++) { Task task = new Task(…); space.write(task, …); } for (int i = 0; i < totalTasks; i++) { Result template = new Result(…); Result result = (Result)space.take(template, …); //… combine results }

20. 20 Replicated-worker pattern The master iterates through all the tasks that need to be computed creating an Entry for each and writing it into the space The master iterates again, this time removing as many result entries from the space as there were tasks and combining them into some meaningful form

21. 21 Replicated-worker pattern Pseudocode for the workers: public class Worker { for (;;) { Task template = new Task(...); Task task = (Task)space.take(template,...); Result result = compute(task); space.write(result,...); }

22. 22 Replicated-worker pattern A worker repeatedly removes a task from the space, computes it, and writes the result of the computation back into the space, where it will be picked up by the master process

23. 23 Second example Mandelbrot Set The problem consists mainly in the computation of an image, following a specific mathematical formula We are interested in the nature of the problem, where each pixel can be computed independently of all the rest JavaSpaces solves this problem very cleanly

24. 24 Second example: Master The master generates a task for each scanline that need to be displayed writing it to the space It then “sleeps” waiting for the workers to do their job It finally collects the result (in whatever order it finds them) and combine them drawing the result to the screen

25. 25 Second example: Master First iteration (building tasks) Second iteration (combine them)

26. 26 Second example: Workers Each worker repeatedly removes a task from the space, computes the color values for the scanline represented by the task and writes the result back to the space for the master to pick up