Active Containers Toolkit

Cornell University, Spring 1999

Contents

• General Overview
• Active Containers
• Active Messages
• Useful Links

General Overview
Numerous protocols have been designed to implement memory coherency on clusters. The majority of these approaches support multiple readers and multiple writers accessing shared memory. By weakening this constraint, we have designed and implemented a high performance, relatively transparent toolkit for multiple reader, single writer shared objects. Our toolkit is called Active Containers.

Active Containers is a C++ library that can be seamlessly incorporated into a variety of applications. The toolkit relies on a low-latency communication layer that we built according to the Active Message 2 (AM2) API. Function shipping and lazy update evaluation are done to maximize performance. The Active Containers toolkit is useful for implementing replication schemes such as process pairs, applications that require shared state such as a cluster wide task manager, and applications that update data in a push model such as the grid coloring demo discussed below.

Active Containers
The toolkit includes reader and writer active containers. To share an object the writer creates a writer active container and then routes all method calls through the container as opposed to the original structure. To receive updates a reader creates a reader active container and then calls the container’s GetCont function to access the object.

The reader and writer internals are fairly straight-forward. When a writer is created, it informs the name service of its existence, makes the necessary active message constructs, and maintains both a pointer to the shared object and a list of readers. Upon receiving a function call, the writer container forwards the call to the shared object and sends the function id with marshaled arguments to each of the readers. When an update is received, the reader container places the message in a queue for lazy evaluation when the GetCont function is called. Figure 1 below illustrates the roles of the two containers. SO refers to copies of the object. The queue is a FIFO queue of updates. H is the active message handler.

Active Messages
The toolkit uses a low-latency communication layer that adheres to the Active Message 2 (AM2) API. A good overview of Active Messages can be found in "A Mechanism for Integrated Communication and Computation" by Thorsten von Eicken, David E. Culler, Seth Copen Goldstein, and Klaus Erik Schauser. AM2 generalizes previous AM interfaces to support multiple, independent processes using the same network resources. AM2 also supports multi-threaded applications and advanced error-handling, while following a more standard asynchronous communication event-handling model. The AM2 interface provides a set of over 45 functions for manipulating the Active Messages layer. The majority of these deal with endpoint and bundle management and the sending of active message re-quests and replies.

AMVI is our implementation of the AM2 interface which uses the Virtual Interface architecture (VI). The code for AMVI, along with a test program, is on the Using AMVI webpage. A description of the source files may be found on the AMVI Source Code webpage.

Useful Links
AC Source Code (acsource.zip)
AMVI Source Code (amsource.zip)
White Paper (activeContianersPaper.pdf)
Using the Toolkit webpage
Source Code for the Active Containers Toolkit webpage
Using AMVI webpage
AMVI Source Code webpage.

Website created by: Ted Bonkenburg ( tb@cs.cornell.edu ) and Vicky Weissman ( vickyw@cs.cornell.edu )