Martin Alt

A grid workflow language using high-level petri nets

One approach to Grid application programming is to implement services with often-used functionality on high-performance Grid hosts. Complex applications are created by using several services and specifying the workflow between them. We discuss how the workflow of Grid applications can be described easily as a High-Level Petri Net (HLPN), in order to orchestrate and execute distributed applications on the Grid automatically. Petri Nets provide an intuitive graphical workflow description, which is easier to use than script-based descriptions and is much more expressive than directed acyclic graphs (DAG). In addition, the workflow description can be analysed for certain properties such as deadlocks and liveness, using standard algorithms for HLPNs. We propose a platform-independent, XML-based language, called Grid Workflow Description Language (GWorkflowDL), and show how it can be adapted to particular Grid platforms. As two example target platforms, we discuss Java/RMI and the current WSRF standard.

Adapting Java RMI for grid computing

Computational grids allow the users to run their applications on remote high-performance servers available via Internet. Java is often used to develop portable grid applications, with programs being sequences (compositions) of remote method calls. We demonstrate an inherent inefficiency of the standard remote method invocation (RMI) mechanism of Java for implementing compositions of remote calls. We propose a new, optimised RMI mechanism, called future-based RMI, that substantially reduces the unnecessary communication overhead of method compositions in a grid environment. We present an analytical model for estimating the performance improvements achieved by our mechanism and report experimental results for two case studies on a grid testbed including a high-performance shared-memory server which is accessed from a client located 500 km away.

Future-Based RMI: Optimizing Compositions of Remote Method Calls on the Grid

We argue that the traditional RMI (remote method invocation) mechanism causes much unnecessary communication overhead in Grid applications, which run on clients and outsource time-intensive method calls to high-performance servers. We propose future-based RMI, an optimization to speed up compositions of remote methods, where one method uses the result of another method as an argument. We report experimental results that confirm the performance improvement due to the future-based RMI on a prototypical Grid system on top of Java.

Using Skeletons in a Java-Based Grid System

Grid systems connect high-performance servers via the Internet and make them available to application programmers. This paper addresses the challenge of software development for Grids, by means of reusable algorithmic patterns called skeletons. Skeletons are generic program components, which are customizable for a particular application and can be executed remotely on high-performance Grid servers. We present an exemplary repository of skeletons and show how a particular application, FFT (Fast Fourier Transform), can be expressed using skeletons and then executed using RMI (Remote Method Invocation). We describe a prototypical Java-based Grid system, present its optimized RMI mechanism, and report experimental results for the FFT example.

Towards high-level grid programming and load-balancing: a Barnes-hut case study

We propose a high-level approach to grid application programming, based on generic components (skeletons) with prepackaged parallel and distributed implementations and integrated load-balancing mechanisms. We present an experimental Java-based programming system with skeletons and use it on a non-trivial, dynamic application – the Barnes-Hut algorithm for N-body simulation. The proposed approach hides from the application programmer many complex details of grid programming and load-balancing, and demonstrates good performance on an experimental grid testbed.

A prototype Grid system using Java and RMI

Grids aim to combine different kinds of computational resources connected by the Internet and make them easily available to a wide user community. While initial research focused on creating the enabling infra-structure, the challenge of programming the Grid has recently become increasingly important. The difficulties for application programmers lie in the highly heterogeneous and dynamic nature of Grid environments. We address this problem by employing reusable algorithmic patterns, called skeletons. Skeletons are used, in addition to the usual library functions, as generic algorithmic building blocks, customizable for particular applications. We describe an experimental Grid programming system, focusing on improving the Java RMI mechanism and the predictability of Java performance in a Grid environment.

Algorithmic Skeletons for Metacomputing

Metacomputing means exploiting computer resources that are distributed over the Internet in a transparent, user-friendly way. It is motivated by the requirements of cooperative, computation-intensive, time-critical applications. The recent development of metacomputing systems has led to so-called Computational Grids, whose heterogeneity poses new challenges in software development. In this paper, we propose a novel approach to programming Grid systems using special software components called skeletons. We describe a prototypical implementation in Java and RMI and study the performance on a Grid consisting of multiprocessor clusters.

Grid Programming with Java, RMI, and Skeletons

We have addressed the challenging problem of software design for heterogeneous grids, using a repository of reusable algorithmic patterns called skeletons, that are executed remotely on high- performance grid servers. While the use of skeletons in the parallel setting is an active research area, their application for grid systems is a new, intriguing problem.

Performance Prediction of Java Program for Metacomputing

We address the challenging problem of program design for metacomputing in the heterogeneous, highly dynamic Internet environment, by providing the application user with a set of parameterized components called skeletons. This paper focuses on estimating the execution time of the application-specific program parts expressed in Java. Our results allow a reliable performance prediction for the execution of skeleton-based programs on remote Internet servers.