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.