Grid computing aims to integrate collections of heterogeneous resources across administrative boundaries into a single virtual system (a grid). Developing grid applications is tremendously difficult due to portability problems and changing, unstable middleware. Moreover, different sites use different (versions of) middleware. The Java Grid Application Toolkit (JavaGAT) overcomes these problems. The JavaGAT is a middleware-independent programming interface to grid systems that simplifies the development of portable grid applications tremendously.

JavaGAT solves three problems that interfere with the widespread adoption of grid technology for production use today: First, a large number of wildly varying grid middleware systems is currently being developed. The standardization landscape has not settled yet, and grid technology and application programming interfaces (API's) are still a topic of research. As of today, grid middleware and API's change frequently and are often unstable or incomplete. Furthermore, the various middleware packages often offer different functionality.

Second, as grid computing still is a research area with many open questions, middleware implementations tend to focus on technical issues, and provide low-level programming interfaces as a result. For instance, the Globus toolkit, a widely used middleware platform, significantly changed its API across the last three major versions. However, all versions expose the underlying technology (respectively proprietary protocols, web-services and the Web Services Resource Framework (WSRF)). It is clear that this is interesting and necessary research, but for today's grid users these technical details are less relevant, and exposing them is counter productive. Much like home appliance users are not interested in the details of electrical power generation, grid application programmers are typically not interested in the technical issues behind the grid, and want to use the grid for production systems today, using a high-level interface.

Third, heterogeneity in processors, the operating system, constantly changing and evolving middleware, and the fact that different grid sites use different grid middleware make it extremely difficult to develop and deploy portable grid applications.

The JavaGAT API is object oriented and offers high-level functionality for accessing the grid, independent of the grid middleware that implements this functionality. JavaGAT lessens the grid application programming burden by providing a uniform interface that provides file access, job submission, monitoring, and access to information services. As a result, grid application programmers need only learn a single API to obtain access to the entire grid. Currently, the JavaGAT is used for application codes, portals, data managements systems, etc. The problem of heterogeneous processors and operating systems is solved by exploiting Java and its virtual machine-based approach.

The JavaGAT sits in between grid applications and numerous types of grid middleware, such as Globus, Unicore, SSH or Zorilla. Due to its modular design, the JavaGAT can easily be extended with support for other grid middleware layers.

With JavaGAT, grid applications do not use grid middleware directly. Instead, the applications calls methods of the GAT API. The GAT engine dynamically "routes" the API calls to the respective grid middleware. We have plug-ins (called adaptors) for many different grid middleware systems, including different Globus versions, SSH, and the peer-to-peer middleware Zorilla.

JavaGAT integrates multiple grid middleware systems with different and incomplete functionality into a single, consistent system, using a technique called intelligent dispatching. This technique dynamically forwards (dispatches) application calls on the JavaGAT API to one or more grid middlewares that implement the requested functionality. The selection process is done at runtime, and uses policies and heuristics to automatically select the best available middleware, enhancing portability. If a grid operation fails, the intelligent dispatching feature will automatically select and dispatch the API call to an alternative grid middleware. This process continues until a grid middleware successfully performs the requested operation, achieving transparent fault tolerance. The JavaGAT defines special nested exceptions that contain the reason for failure for each individual middleware. When no grid middleware can perform the requested operation, the JavaGAT throws the nested exception to facilitate reasoning about errors and debugging, improving application reliability.

Equally important, JavaGAT defines a framework for developing grid middleware bindings. The framework contains a large collection of generic code, significantly simplifying this process. It is important to recognize that the middleware developers are as important as the end users: without robust bindings to middleware, a grid API is of little use. Because of the sheer number of different middleware systems and their permanently changing APIs, we cannot provide access to all middleware systems ourselves. Furthermore, because writing middleware bindings for JavaGAT is straightforward, middleware developers achieve the freedom to experiment with different architectural designs and new techniques. This can now be done without interfering with the application programmers, as the top-level API (the JavaGAT API) remains stable.

By offering solutions for the heterogeneity problems, while providing high-level programming interfaces, we achieve functionality that grid users urgently need today, despite the (flaws of) evolving middleware, bringing production use of the grid a step closer. JavaGAT is freely available as open source software. For more information and downloads, see http://www.cs.vu.nl/ibis/.

-----

A paper describing the Java Grid Application Toolkit in greater detail will be presented on Wednesday, Nov. 14, at SC07. For more information, visit http://sc07.supercomp.org/schedule/event_detail.php?evid=11089.