The current focus of the Computing Communities project is on transparently endowing unmodified general-purpose Win32 applications (running on Windows NT platforms) with a representative subset of the CC features.

A CC is realized by first "lifting" an application off of the base operating system. Central to our design is the well-known technique of API interception, increasingly relevant given current-day OS structures that delegate a large portion of the OS functionality to dynamically-linked libraries (DLLs). We use existing API interception techniques as a means of interfacing the application with our middleware layers.

Our current research is focused on the following three areas:

  1. Virtualization: To enable unmodified general-purpose applications to benefit from the features of a CC, we rely on a virtual operating system (VOS) layer that shields running applications from the static nature of the underlying OS. This VOS forms the core of the CC software. All API requests made by the application to the base OS are diverted to the VOS, which executes them (often invoking the original base OS routine), in a manner consistent with the needs of the CC. The VOS also virtualizes all CC resources, making it possible to dynamically change the mapping of virtual handles (exposed to the application) to physical resources.

    We have prototyped different techniques for exploiting the base API interception technique to achieve complete efficient virtualization of various system resources (output, files, network connections, etc.). Additional details about these prototypes can be found in the CANPC'00, ICDCS'00, and USENIX-WSS'00 papers. Current efforts are focused on developing a general API interception and replay framework which can automatically synthesize VOS  components starting from a high-level specification of required virtualization functionality.

  2. Adaptation: We are designing a general-purpose application adaptation architecture to enable an application to take full advantage of dynamically available CC resources, that might differ both qualitatively and quantitatively from the resources that the application is currently using. We are investigating both application-independent and application-aware techniques. The former includes techniques such as eager scheduling, two-phase idempotent execution, checkpointing, mirroring, and data dispersal, that permit an application to take advantage of a mismatch between required and available resources; the additional resources are utilized to provide more robust application behavior.

    Application-aware techniques provide an API for CC-aware applications that allows computations to become aware of and gracefully adapt themselves to changes in CC resource characteristics. Our approach combines a natural, high-level specification of alternate application execution paths (collectively referred to as a tunable application) with an automatic run-time strategy for invoking these paths as necessary. Additional details about the adaptation framework can be found in the IPPS/SPDP'99, JPDC'00, HPDC'00, and Cluster Computing'01 papers.

    As an example of application-oblivious adaptation techniques, we have been working on a system called CANS: Composable Adaptive Network Services. CANS generalizes the notion of a network path connecting client and server applications into a network-aware data path augmented  with stream-specific drivers. These drivers are inserted transparently into the data path, based upon high-level type specifications of client and server behaviors, and the underlying network. The CANS architecture is described in a USITS'01 paper. A more recent technical report describes and evaluates planning and reconfiguration algorithms for selecting and mapping an appropriate combination of drivers under (possibly dynamically changing) different network conditions. Additional details about the CANS project can be obtained here.


  3. Global Resource Management: The CC infrastructure coalesces independent computing and information resources into a single, virtual multiprocessor that is accessible to an application. However, given the autonomous nature of these resources, the CC software must respect any access restrictions and resource sharing agreements that might exist among the involved principals. For example, a principal bringing in CPU resources into the CC might require that only certain other principals be allowed to use it, and then too in only limited quantities.

    We are investigating efficient, scalable methods for expressing and scheduling such dynamic resource sharing agreements in large distributed environments, together with the system support required to enforce these agreements in an application-oblivious fashion. Our SC'2000 paper describes a scheme that exploits the notion of tickets and currencies for expressing such agreements, and proposes a linear-programming scheme for their transitive enforcement. A redirector-based architecture for distributed enforcement of sharing agreements is described in a recent report.