JavaSpaces TM

1. JavaSpacesTM By Stephan Roorda Source: JavaSpaces specification

2. Presentation Outline • Review of Linda • Overview of JavaSpaces • In depth description of JavaSpaces • Why is JavaSpaces better?

3. Review of Linda

4. Linda Basics • Tuple space is Linda's name for its shared data space • A Tuple is simply a list of fields, separated by commas and enclosed in parentheses • A tuple is accessed by specifying its contents • Associative memory model • There is no address associated with a tuple

5. Tuple Space Sender Sender Tuple Space Receiver Receiver

6. Linda Operations • There are four basic operations: • out • Generates a data (passive) tuple. • Each field is evaluated and put into tuple space. • in • Uses a template to retrieve tuple from tuple space • Once retrieved, the tuple is taken out of tuple space and is no longer • If no matching tuple is found process will block. Provides for synchronization between processes.

7. Linda Templates • Specifies tuple to retrieve • Consists of sequence of typed fields • Two kinds of fields • Actuals • Variables, constants or expression that resolve to constant • Formals • Holders for data to retrieve • Preceded by a question mark • Assigned values of corresponding fields in matched tuple

8. Matching Templates • In order for a template to match a tuple: • Have to have the same number of fields • Actuals must have same type, length and values as those in corresponding tuple fields • Formals in template must match type and length of corresponding fields in tuple • If several tuples match the template, impossible to predict which will be selected • The order of evaluation of fields within a tuple or template is undefined.

9. Linda Operations • rd • Uses a template to copy data without removing it from tuple space. • Once read, the tuple is still available for others. • If no matching tuple is found process will block. • eval • Generates process (active) tuple • Control is immediately returned to invoking program • Logically, each field is evaluated concurrently, by a separate process and then placed into tuple space

10. Quote

11. Overview of JavaSpaces

12. Mapping Linda to JavaSpaces • JavaSpace = Tuple Space • entry = tuple • write = out • take = in • read = rd

13. Differences between Linda and JavaSpaces • Entries in Java are typed as objects • associates behavior with entries • JavaSpaces allows matching of subtypes • result of having typed entries • Fields in an entry are objects in Java • systems built with this are object-oriented

14. Differences • Support for multiple JavaSpaces • transactions can span multiple threads and spaces • Leasing • frees system from garbage left behind from crashes • JavaSpaces does not provide eval

15. JavaSpaces Design Goals • Provide a simple platform for designing and implementing distributed systems • Thin clients • simple • quick to download • run on limited local memory

16. JavaSpaces Design Goals • Variety of server implementations • relational databases • object oriented databases • It should be possible to create a replicated JavaSpaces service

17. Requirements for Application Clients • Must be possible to write a 100% Pure Java client • Clients implementation must be independent of the implementation details of the Server

18. Key features of JavaSpaces • Spaces are shared • handles the details of concurrent access • Spaces are persistent • objects can outlive the processes that created them • Spaces are associative • associative lookup is used to locate objects • this is based on content and not memory location

19. Key features • Spaces are transactionally secure • transaction model ensures that an operation on a space is atomic • supported for one or more spaces • Spaces allow us to exchange executable content • objects are passive in the space( immutable ) • when removed we can change their attributes and invoke methods on them

20. Entry • Collection of typed objects package net.jini.core.entry; public interface Entry extends java.io.Serializable { // this interface is empty }

21. Example Entry import net.jini.core.entry.*; public class SpaceShip implements Entry { public Integer score; public String name; public MessageEntry() { } public SpaceShip( String n, int s ) { score = s; name = n; } }

22. JavaSpace Interface • All of the operations have to be invoked on an object that implements the JavaSpace interface • Not a remote interface • Exports objects that implement the JavaSpace interface locally on the client

23. JavaSpace Interface package net.jini.space; <import statements> public interface JavaSpace { public final long NO_WAIT = 0; Lease write( Entry e, Transaction txn, long lease ) Entry read( Entry tmpl, Transaction txn, long timeout ) Entry take( Entry tmpl, Transaction txn, long timeout ) EventRegistration notify( Entry tmpl, Transaction txn, RemoteEventListener listener, long lease, MarshalledObject handback ) }

24. Accessing a JavaSpace • Space might be registered as a Jini lookup service • Space might register with an RMI registry

25. Operations • Write • Read • Take • Notify

26. write • Write the given entry into this JavaSpaces service public void writeShip( SpaceShip ship ) { try { space.write( ship, null, Lease.FOREVER ); } catch( Exception e ) { e.printStackTrace(); } }

27. read and readIfExists • Read an entry from the JavaSpaces service that matches the given template • Passing a null reference for the template will match any Entry • Multiple read requests may return different Entry objects even if no changes are made to the space in between each

28. read and readIfExists public int getScore( String name ) { SpaceShip template = new SpaceShip(); template.name = name; try { SpaceShip ship = (SpaceShip)space.read( template, null, Long.Max_VALUE ); return ship.score.intValue(); } catch( Exception e ) { e.printStackTrace(); return -1; } }

29. Silly Sample public static void main( String args[] ) { JavaSpace space = SpaceAccessor.getSpace(); SpaceGame game = new SpaceGame( space ); // create an entry SpaceShip enterprise = new SpaceShip( “enterprise”, 10 ); // demonstrate read and write game.writeShip( enterprise ); System.out.println(enterprise.name + “ written into space”); System.out.println(“The “ + enterprise.name + “’s score is “ + game.getScore(“enterprise”) ); }

30. take and takeIfExists • Same as Read operations, except that the entry is removed from the space • Will never return copies of the same Entry

31. take and Exceptions • RemoteException - may or may not have been successful • UnusableEntryException - removes the unusable entry from the space • Any other exception - take did not occur and no entry was removed from the space

32. notify • Notify a specific object when entries that match the given template are written into this JavaSpaces service • A lease time is given which is how long you want the registration to be remembered by the server

33. Events in Java • Event Source • Event Object • Event Listener

34. Distributed Events in JavaSpaces • Events might have to travel from one JVM to another over a network • Events may arrive: • multiple times • out of order • not at all • Programmer’s responsibility to ensure correctness

35. Event notification in JavaSpaces

36. Notification Example public static void main( String args[] ) { JavaSpace space = SpaceAccessor.getSpace(); Listener listener = new Listener( space ); Message template = new Message(); space.notify(template, null, listener, Lease.FOREVER, null); Message msg = new Message(); msg.content = “Hello World”; space.write( msg, null, Lease.FOREVER ); }

37. Notification Example public class Listener implement RemoteEventListener { private JavaSpace space; public Listener( JavaSpace space ) throws RemoteException { this.space = space; UnicastRemoteObject.exportObject( this ); } public void notify( RemoteEvent ev ) { Message result = (Message)space.read( template, null, Long.MAX_VALUE ); System.out.println( result.content ); } }

38. notify and Transactions • Transactions can be: • null • non - null

39. notify and Transactions • entries that are written and taken in the same transaction - before a commit - listeners will not be notified that are registered under a null transaction • server retries until the notification request’s lease expires • notifications may be delivered in any order

40. Operation Ordering • operations on a space are unordered • Example: if T and U are 2 threads. T performs a write and U performs a read with a template that matches the written entry, the read may not find the written entry even if the write returns before the read. • The only way to guarantee this is if the threads work together and that is independent of JavaSpaces

41. Transactions • uses net.jini.core.transaction to group operations into a bundle that act as a single transaction • either all operations within the transaction complete or none do • null - performs as if a transaction was created just for that operation

42. Benefits of JavaSpaces • Simple • Expressive • Supports loosely coupled protocols • Eases the implementation of client/server systems

43. Applications of JavaSpaces • Any system/problem that needs a distributed solution • Human Genome project • Cryptography • Rendering • Chat program • Auction server( such as e-bay, amazon, etc )

44. Examples

45. Conclusion • Simple to learn • Easy to understand • Map a lot of problems • fairly new - not many “real-world” uses yet • best implementation of Linda yet

46. References and Sources • JavaSpaces Principles, Patterns, and Practice by Freeman, Hupfer, Arnold • Official JavaSpaces specification • visit http://www.cs.rit.edu/~sjr1521 for full links and bibliography