Tuple space: Difference between revisions
→JavaSpaces: Linked to the encyclopedia entry for 'low-latency'. |
|||
Line 21: | Line 21: | ||
JavaSpaces is a service specification providing a distributed object exchange and coordination mechanism (which may or may not be persistent) for [[Java platform|Java]] objects. It is used to store the distributed system state and implement [[distributed algorithm]]s. In a JavaSpace all communication partners (peers) communicate and coordinate by sharing state. |
JavaSpaces is a service specification providing a distributed object exchange and coordination mechanism (which may or may not be persistent) for [[Java platform|Java]] objects. It is used to store the distributed system state and implement [[distributed algorithm]]s. In a JavaSpace all communication partners (peers) communicate and coordinate by sharing state. |
||
JavaSpaces can be used to achieve [[scalability]] through parallel processing, it can also be used to provide reliable storage of objects through distributed replication, although this won't survive a total power failure like a disk; it is regarded by many to be reliable as long as the power is reliable. Distribution can also be to remote locations; however, this is rare as JavaSpaces are usually used to low-latency, high performance applications rather than reliable object caching. |
JavaSpaces can be used to achieve [[scalability]] through parallel processing, it can also be used to provide reliable storage of objects through distributed replication, although this won't survive a total power failure like a disk; it is regarded by many to be reliable as long as the power is reliable. Distribution can also be to remote locations; however, this is rare as JavaSpaces are usually used to [[low-latency]], high performance applications rather than reliable object caching. |
||
The most common [[software pattern]] used in JavaSpaces is the Master-Worker pattern. The Master hands out units of work to the "space", and these are read, processed and written back to the space by the workers. In a typical environment there are several "spaces", several masters and many workers; the workers are usually designed to be generic, i.e. they can take any unit of work from the space and process the task. |
The most common [[software pattern]] used in JavaSpaces is the Master-Worker pattern. The Master hands out units of work to the "space", and these are read, processed and written back to the space by the workers. In a typical environment there are several "spaces", several masters and many workers; the workers are usually designed to be generic, i.e. they can take any unit of work from the space and process the task. |
Revision as of 09:21, 24 September 2009
A tuple space is an implementation of the associative memory paradigm for parallel/distributed computing. It provides a repository of tuples that can be accessed concurrently. As an illustrative example, consider that there are a group of processors that produce pieces of data and a group of processors that use the data. Producers post their data as tuples in the space, and the consumers then retrieve data from the space that match a certain pattern. This is also known as the Blackboard Metaphor. Tuple space may be thought as a form of distributed shared memory.
Tuple spaces were the theoretical underpinning of the Linda language developed by David Gelernter and Nicholas Carriero at Yale University.
Implementations of tuple spaces have also been developed for Smalltalk, Java (JavaSpaces), Python, Ruby, TCL, Lua, Lisp, Prolog and the .NET framework.
Object Spaces
Object Spaces is a paradigm for development of distributed computing applications. It is characterized by the existence of logical entities, called Object Spaces. All the participants of the distributed application share an Object Space. A provider of a service encapsulates the service as an Object, and puts it in the Object Space. Clients of a service then access the Object Space, find out which object provides the required service, and have the request serviced by the object.
Object Spaces, as a computing paradigm, was put forward by David Gelernter at Yale University. Gelernter developed a language called Linda to support the concept of global object coordination.
Object Space can be thought of as a virtual repository, shared amongst providers and accessors of network services, which are themselves abstracted as objects. Processes communicate among each other using these shared objects — by updating the state of the objects as and when needed.
An object, when deposited into a space, needs to be registered with a Object Directory in the Object Space. Any processes can then identify the object from the Object Directory, using properties lookup, where the property specifying the criteria for the lookup of the object is its name or some other property which uniquely identifies it. A process may choose to wait for an object to be placed in the Object Space, if the required object is not already present.
Objects, when deposited in an Object Space are passive, i.e., their methods cannot be invoked while the objects are in the Object Space. Instead, the accessing process must retrieve it from the Object Space into its local memory, use the service provided by the object, update the state of the object and place it back into the Object Space.
This paradigm inherently provides mutual exclusion. Because once an object is accessed, it has to be removed from the Object Space, and is placed back only after it has been released. This means that no other process can access an object while it is being used by one process, thereby ensuring mutual exclusion.
JavaSpaces
JavaSpaces is a service specification providing a distributed object exchange and coordination mechanism (which may or may not be persistent) for Java objects. It is used to store the distributed system state and implement distributed algorithms. In a JavaSpace all communication partners (peers) communicate and coordinate by sharing state.
JavaSpaces can be used to achieve scalability through parallel processing, it can also be used to provide reliable storage of objects through distributed replication, although this won't survive a total power failure like a disk; it is regarded by many to be reliable as long as the power is reliable. Distribution can also be to remote locations; however, this is rare as JavaSpaces are usually used to low-latency, high performance applications rather than reliable object caching.
The most common software pattern used in JavaSpaces is the Master-Worker pattern. The Master hands out units of work to the "space", and these are read, processed and written back to the space by the workers. In a typical environment there are several "spaces", several masters and many workers; the workers are usually designed to be generic, i.e. they can take any unit of work from the space and process the task.
JavaSpaces is part of the Java Jini technology, which on its own has not been a commercial success. The technology has found and kept new users over the years and some vendors are offering JavaSpaces-based products. JavaSpaces remains a niche technology mostly used in the financial services and telco industries where it continues to maintain a faithful following. The announcement of Jini/JavaSpaces created quite some hype although Sun co-founder and chief Jini architect Bill Joy put it straight that this distributed systems dream will take "a quantum leap in thinking".[1]
Example usage
The following example shows an application made using JavaSpaces. First, an object to be shared in the Object Space is made. Such an object is called an Entry in JavaSpace terminology. Here, the Entry is used to encapsulate a service which returns a Hello World! string, and keeps track of how many times it was used. The server which provides this service will create an Object Space, or JavaSpace. The Entry is then written into the JavaSpace. The client reads the entry from the JavaSpace and invokes its method to access the service, updating its usage count by doing so. The updated Entry is written back to the JavaSpace.
// An Entry class
public class SpaceEntry implements Entry
{
public final String message = "Hello World!";
public Integer count = 0;
public String service() {
count = count + 1;
return message;
}
public String toString() {
return "Count: " + count;
}
}
// Hello World! server
public class Server
{
public static void main(String[] args) throws Exception
{
SpaceEntry entry = new SpaceEntry(); // Create the Entry object
JavaSpace space = (JavaSpace)space(); // Create an Object Space
// Register and write the Entry into the Space
space.write(entry, null, Lease.FOREVER);
// Pause for 10 seconds and then retrieve the Entry and check its state.
Thread.sleep(10*60*1000);
SpaceEntry e = space.read(new SpaceEntry(), null, Long.MAX_VALUE);
System.out.println(e);
}
}
// Client
public class Client
{
public static void main(String[] args) throws Exception
{
JavaSpace space = (JavaSpace) space();
SpaceEntry e = space.take(new SpaceEntry(), null, Long.MAX_VALUE);
System.out.println(e.service());
space.write(e, null, Lease.FOREVER);
}
}
Implementations
- The Fly Object Space - implementations for Java, Scala and Ruby
- The Blitz Project (open-source single site server)
- SlackSpaces (open-source) (main site is down, but project source is downloadable)
- GigaSpaces (commercial, clustered, fault-tolerant)
- PyLinda implementation for Python
- Rinda implementation for Ruby
- LinuxTuples (open-source, clustered, API for C and Python)
- SemiSpace (open-source, clustered (with Terracotta Cluster)) Java implementation
- TSpaces (An implementation by IBM using Java)
- LIME (Linda in a Mobile Environment)
- SQLSpaces - (open-source (GPL & LGPL), server implementation in Java, clients for Java, C#, Prolog, PHP, Ruby)
Books
- Eric Freeman, Susanne Hupfer, Ken Arnold: JavaSpaces Principles, Patterns, and Practice. Addison-Wesley Professional, 1. June 1999, ISBN 0-201-30955-6
- Phil Bishop, Nigel Warren: JavaSpaces in Practice. Addison Wesley, 2002, ISBN 0-321-11231-8
- Max K. Goff: Network Distributed Computing: Fitscapes and Fallacies, 2004, Prentice Hall, ISBN 0131001523
- Sing Li, et al.: Professional Java Server Programming, 1999, Wrox Press, ISBN 1861002777
- Steven Halter: JavaSpaces Example by Example., 2002, Prentice Hall PTR, ISBN 0-13-061916-7
Interviews
- Heiss, Janice J. (2003). "Computer Visions: A Conversation with David Gelernter". Sun Developer Network (SDN).
- Venners, Bill (2003). "Designing as if Programmers are People (Interview with Ken Arnold)". java.net.
- Haines, Steven (2006). "Interview: GigaSpaces". InformIT.
Articles
- Brogden, William (2007). "How Web services can use JavaSpaces". SearchWebServices.com. Retrieved 2007-04-18.
- Brogden, William (2007). "Grid computing and Web services (Beowulf, BOINC, Javaspaces)". SearchWebServices.com. Retrieved 2007-03-20.
- White, Tom (2005). "How To Build a ComputeFarm". java.net. Retrieved 2005-05-21.
- Ottinger, Joseph (2007). "Understanding JavaSpaces". theserverside. Retrieved 2007-01-31.
- Angerer, Bernhard (2005). "Loosely Coupled Communication and Coordination in Next-Generation Java Middleware". java.net. Retrieved 2006-06-03.
{{cite web}}
: Unknown parameter|coauthors=
ignored (|author=
suggested) (help) - Angerer, Bernhard (2003). "Space-Based Programming". onjava.com. Retrieved 2003-03-19.
- Sing, Li (2003). "High-impact Web tier clustering, Part 2: Building adaptive, scalable solutions with JavaSpaces". IBM developerworks.
- Mamoud,, Qusay H. (2005). "Getting Started With JavaSpaces Technology: Beyond Conventional Distributed Programming Paradigms". Sun Developer Network (SDN).
{{cite web}}
: CS1 maint: extra punctuation (link) - Hupfer, Susanne (1999). "Make room for Javaspaces, Part 1 (from 5)". JavaWorld.
- Löffler, Dr. Gerald (2004). "JavaSpaces und ihr Platz im Enterprise Java Universum, Das Modell zum Objektaustausch: JavaSpaces vorgestellt". Entwickler.com. Retrieved 2004-02-01.
- Shalom, Nati (2006). "Space-Based Architecture and the End of Tier-Based Computing". GigaSpaces Technologies.
References
- ^ Rob Guth: "More than just another pretty name: Sun's Jini opens up a new world of distributed computer systems". SunWorld, August 1998 [15. Januar 2006]
See also
- Space-based architecture
- Linda (coordination language)
- Ken Arnold, lead engineer on JavaSpaces at Sun Microsystems
- Rinda, a JavaSpaces analog for Ruby
Sources
- Gelernter, David. "Generative communication in Linda". ACM Transactions on Programming Languages and Systems, volume 7, number 1, January 1985
- Distributed Computing (First Indian reprint, 2004), M. L. Liu
External links
- "TupleSpace" at c2.com
- "JavaSpace Specification" at jini.org