Projects Members Contact Us Back to HiPerSoft Home Page
Projects Visit Rice University

Runtime Support for Grid Applications

The GrADS research program focuses on integrated application development rather than on the underlying network and computational infrastructure from which the Grid is constructed. The runtime support service required for GrADS application development can be partitioned into two general classes.

A first set are concerned with such concerns as resource management, resource location, resource scheduling, and security (i.e., the basic capabilities required to execute applications in Grid environments). For these we will rely on the services provided by Globus system, with various enhancements motivated by the specific requirements of the GrADS framework.

A second set of services, to be developed as part of this research is concerned more specifically with the information infrastructure and event notification capabilities required to support the development of grid-aware applications. A grid-aware application is one that at runtime can identify Grid characteristics and then dynamically reconfigure resource requirements and/or application structure to maintain desired application-level performance.

Experience with the development of prototype grid-aware applications leads us to believe that robust application performance can only be achieved if all system components are allowed to advertise their performance requirements and expectations to other elements of the system, and then react if those requirements are not being met. Thus applications and GrADS components must be able to push performance specifications into the runtime system as well as pull dynamic performance information from the run-time system so that scheduling and resource control mechanisms can make effective decisions based on application and user requirements.

Research Directions

Performance Contracts -- The creation of modular system components that are efficient in dynamic Grid environments will require new interface specifications and assertion mechanisms. These mechanisms must be able to match the resource needs of modules with deliverable performance and capabilities of resources.

The performance contract is the vehicle for sharing complex, multi-dimensional performance information between application and system components, enabling a dynamic negotiation process to occur between resource provider and consumers. A performance contract may involve performance goals, cost limits, scheduling constraints, and other requirements. These elements may be specified by the application or derived by other GrADS components. We will develop a calculus of performance-contract negotiations and study the use of dynamic contract negotiations to create interoperable applications, libraries, compilers, and runtime systems. In addition, a service negotiator will be developed to orchestrate interactions among upper-level components and the underlying systems, as dictated by their performance contracts.

  • Runtime Support for Adaptive Strategies -- The dynamic performance characteristic of Grid environments require new strategies for achieving application performance. GrADS components and tools must be able to support both the development and execution of adaptive "Grid-aware" applications. Such applications will require performance information that depends on their function and structure, as well as the time-frame in which they will execute. New strategies must be developed so that the compiler, scheduler, runtime system, and other GrADS components cooperate to extract pertinent information from Grid applications non-intrusively, and can feed it back to the application level as necessary.
  • Development of Performance Economy -- The development of a performance contract and a service negotiation framework will result in a system in which all components can participate in a virtual "performance economy." The development of a framework to support the negotiation of performance contracts for GrADS applications will be critical to the efficient functioning of the GrADS system. This work will investigate the development of performance economies and the way in which they can be structured to optimize the behavior of GrADS applications.
  • Compilation and Execution Architecture --- Designing a programming system architecture that supports the GrADS dynamic compilation strategy is a major goal of our language and environment effort. Previous research on runtime compilation has focused on single computer optimization problems, Work related to dynamic optimization for high-performance distributed applications is only now emerging. The system of performance contracts at the heart of this project will make it possible for real-time monitoring system to cooperate with runtime compilers, ensuring that performance goals are met by detecting performance anomalies during execution and initiating reorganization and optimization of computation to remove them.
  • Real-time Monitoring and Adaptive Control --- The transient, rarely repeatable behavior of the Grid means that the standard model of post-mortem performance optimization must be replaced by a real-time model that optimizes application and runtime behavior during program execution. This model of closed loop control will require design of new performance specification interfaces and assertion mechanisms, measurement tools, and decision procedures for adaptive configuration of application modules and runtime system components, as well as compiler interfaces for just-in-time compilation and performance prediction. Via runtime validation of these performance contracts, the real-time measurement and control system will activate dynamic recompilation and runtime resource configuration.



Application Studies -- Our initial goal is to (a) determine how distributed applications could be made reconfigurable and (b) provide programming systems that would make them easier to develop for the Grid. This experiment will be followed in later years by implementation of the same application using the prototype GrADS software development framework.

  • Reconfigurable Object Programs and Dynamic Optimization --- A central goal of the research is to define a standard for reconfigurable object programs and construct a dynamic optimizer that will tailor them to a specific target configuration. The reconfigurable object program should contain all the information necessary to tailor it in the dynamic optimizer. To improve dynamic optimizer performance, the reconfigurable object program may include custom analyzer and transformer generated by the static compiler. A second goal is to generate information sharing and data gathering interfaces that will assist the performance monitoring system in detecting performance problems that must be addressed through reconfiguration. This work will be done in close collaboration with the library effort, which will use the same object program and data gathering framework for the encoding of the parameterized algorithm libraries.
  • Static Compilation Framework --- We will construct an interprocedural framework for analyzing whole programs and generating reconfigurable object programs. The heart of the system will be a language- independent framework for managing the compilation of Java and Fortran programs. This framework will support both intelligent integration of library calls and global performance optimization. Our intent is to simplify the task of adding additional language to the framework. Our own effort will be directed toward the support of Java and Fortran. The output of the static compiler will be a reconfigurable object program, which will be further optimized dynamically when the target configuration is known. By the third year it should be possible to generate statically optimized reconfigurable objects, although much additional work will be needed to improve the code quality.
  • Performance Optimization Toolkit --- We will develop a toolkit for static and dynamic performance tuning that is integrated with the static compilation framework, dynamic optimization and just-in-time compilation systems, object libraries, and PSEs. Based on deep compile-time information, runtime validation of performance contracts, and adaptive control techniques, the performance toolkit will enable users to develop codes that meet performance design goals even when resource availability changes dynamically. The first year will concentrate on the definition of performance contract interfaces and validation mechanisms, with dynamic, adaptive performance measurement and control following in later years.