Source Code and Information

Ivory | Download | Installation
Service Cache Using Ivory | Developing Applications

Ivory Architecture

Ivory is designed to replicate and cache Java data structures. Ivory maintains the data's consistency so that clients can contact either the primary or the replicas to access the data. Replicas do not necessarily have to replicate the primary's entire data store but rather can act as caches--where the amount of data stored and the degree of consistency is determined by the application that uses Ivory.

Data is partitioned based on application-defined groups of related objects, called conits. Based on the assumption that related objects are more likely to be read and modified within the same period of time, using conits adds flexibility into the system and improves system performance in three important ways:

Consistency maintain versions based on conits instead of objects and amortize cost of propagating updates,
Synchronization lock objects with one shared lock, and
Caching amortize cost of faulting objects.

For more information, please see the most recent paper.

Using Ivory

Ivory is a framework that can simplify the construction of dynamic Web services and other services that want to scale automatically and need to maintain the consistency of their data.

Ivory automatically replicates and caches data structures on remote nodes. Clients can request data from either the primary node or the replicas and will receive the same information, within some application-appropriate bound for stale data.

We implemented a simplified service cache using Ivory. Service caches are used to scale dynamic services by replicating the Java code and data used to generate dynamic content. These caches should produce correct results, as would be produced by the server--within some application-appropriate margin of error. We want consistent copies of the code and data, while keeping the client-perceived latency low, and we want to minimize the cost of managing state.

For more information about the implemented service cache, please see Service Cache Using Ivory.

Packages and Directories

There are three Ivory packages: conits, servicecache, and pickles.

The pickles package uses jni code and, therefore, depends on the machine platform.

The conits package is the interface between applications and Ivory.

The servicecache package is the service caching framework. The servicecaching framework is made up of three main components--a name cache, a node manager, and a state manager. The name cache is a table of symbolic names that refer to objects. The node manager maintains information about peer nodes; this information is used to send and receive updates. The most important part of Ivory is the state manager, which manages the conit state and initiates receiving and propagating updates. The state manager can be modified to handle other caching/consistency policies. For more information, see the Java Docs or the paper.

Also included in this release are

the servlets used to initialize the primary server and the replicas. These servlets are in the ivoryserv directory.
an example service, which includes the source code for the data structure and the applications that operate on the data structure. This code is in the testapp directory.

Future Features

The following are known limitations that we plan to fix/add in future releases.

If a replica goes down and is restarted, the data can no longer be replicated until the server is restarted. This is a result of a klug for efficiency. We are looking into alternatives for the next release.
In general, we need to make the system handle errors and exceptions more appropriately.
Persistent storage
Alternate policies for anti-entropy

Sara E. Sprenkle

Last modified: Sat Jun 2 17:09:24 EDT 2001