The current focus of the InSight project is on developing compiler and run-time techniques for utilizing application information to efficiently support shared object-spaces in a variety of parallel and distributed environments.

Central to our approach is the notion of object views, which are high-level descriptions of how a particular thread of computation uses the object. Object views are naturally associated with methods, and can be considered as generalizing object interfaces. For instance, object views can be used to concisely describe the subset of object state accessed by the method and the mode of access (e.g., read or write) or, for specifying concurrency restrictions on the object's methods. In their complete generality, object views can also express domain-specific optimizations as well as constraints on the behavior of a group of objects. Object views preserve encapsulation because they represent high-level specifications, independent of the object implementation. An overview paper describing our approach can be found here.

Our research has focused on the following two themes:

Efficient support of shared object spaces using object views:

Object views can enable efficient maintenance of consistency between object replicas by providing a coherence granularity that entails smaller and lower frequency state transfer (as compared to complete objects) and encapsulating many application-specific optimizations. Towards this end, our research has investigated:

  1. Language support for object views: We are investigating a set of language-neutral extensions that can be applied to existing object-oriented languages and component descriptions for specifying high-level behavior about object usage. A preliminary description of VJava, the Java programming language extended with support for views, can be found in an OOPSLA'99 publication.

  2. Analysis of view consistency requirements: The view specifications are used to first infer consistency requirements of views based upon static analysis of which views are concurrently active and a model of their side-effects. These requirements are then enforced by per-view custom coherence protocols at run-time, which are capable of adapting to both heterogeneous environments and dynamic changes in resource availability.

  3. Run-time mechanisms for implementing view protocols: The per-view consistency requirements are enforced at run time using a novel framework of composable object coherence primitives. One of the issues we are exploring is how to design the primitives so as to take advantage of the increasing availability of high-performance networks such as VIA. Additional details about the composable coherence and scheduling primitives can be found in the JPDC'99, SC'98, and IPPS'97 papers.


Using object views as a structuring basis for building adaptable distributed applications:

Observing that the key notion behind object views is a separation of logical object behaviors from their physical implementation suggests a means for building adaptable distributed applications: component-based applications can adapt to the performance and security characteristics of their execution environments by choosing an appropriate "view" of the component. Since views represent a component's high-level specification, the choice of a component's view can be made independently from that of other components.

The above observation underlies work on the following three infrastructures, being developed with additional funding from DARPA (see the Computing Communities, Distributed Sanctuaries, and Mutable Services project pages):

  1.  Application Tunability explores adaptation at the intra-component level by relying upon a high-level, application-neutral description of the "tunability" of an application component. The underlying system dynamically and automatically decides on an appropriate configuration best suited to the resource properties of the environment. Additional details about the application tunability infrastructure can be found in the JPDC'00 and Cluster Computing'01 papers.

  2. CANS explores adaptation at the level of data paths connecting two components by dynamically augmenting the data path as required with application-specific "transformational" components. These components can perform various activities ranging from protocol conversion to content transcoding. CANS relies upon the object view notion to express alternate components, and multiple instantiations of a particular component. The infrastructure automatically chooses the sequence of components and their specific instantiations, and is capable of dynamically reconfiguring network paths whenever a change in network conditions is detected. Additional details can be found in the USITS'01 paper and a technical report

  3. Partitionable Services explores adaptation at the level of general inter-component interactions. Object views define alternate instantiations of a component, permitting the former to replace the latter as required. For instance, an application-specific caching component can replace the original to offer good performance to clients that are accessing the service across a wide-area connection. Additional details can be found in a forthcoming HPDC'02 paper.