Adarsh Patil

Matching high performance approximate inverse preconditioning to architectural platforms

Abstract In this paper we examine the performance of parallel approximate inverse preconditioning for solving finite element systems, using a variety of clusters containing the Message Passing Interface (MPI) communication library, the Globus toolkit and the Open MPI open-source software. The techniques outlined in this paper contain parameters that can be varied so as to tune the execution to the underlying platform. These parameters include the number of CPUs, the order of the linear system (n) and the “retention parameter” (δl) of the approximate inverse used as a preconditioner. Numerical results are presented for solving finite element sparse linear systems on platforms with various CPU types and number, different compilers, different File System types, different MPI implementations and different memory sizes.

A grid application development platform for WebCom-G

Grid computing is becoming more popular. The traditional role of the Internet as being an information repository is evolving to become a resource repository. People using the Internet want to do more than just look for information, they want to exploit the resources available. Grid computing provides platforms to facilitate such requirements. Various grid middlewares have been developed to offer access to vast resources ranging from computing power to application functionality to specialised physical resources. This paper details the programming model used for heterogeneous environments exploited by WebCom-G. In addition to describing the tools and methodologies used for this computing environment, a brief outline of WebCom-G (WebCom grid) and some of its capabilities is given.

The information gathering module of the webcom-G operating system

The WebCom-G operating system will be designed to act as a sophisticated Grid middleware that will hide middleware and architectural detail from the application programmer. A central goal of WebCom-G is to provide seamless interoperability with existing core grid middlewares. This paper sketches the main components of the WebCom-G OS and presents its information gathering module in detail. This module is pivotal for the implementation of Fault Tolerance, Load Balancing, Quality of Service and hence is vital for the development of a realistic economic model.

WebCom-G: Middleware To Hide The Grid

Current Grid enabling technologies consist of stand-alone architectures. A typical architecture provides middleware access to various services at different hierarchical levels. Services exposed at these levels may be leveraged by the application programmer. However, the level at which the service appears in the hierarchy determines both its richness and the complexity of its use. Thus, benefits gained by using these services are defined by the manner in which they are accessed. Generally, choosing to use a particular service inclines the application programmer to use the associated middleware suite as it is difficult to cherry-pick services across middlewares. Interoperability and independent service access are not easily facilitated in current middlewares. If it is accepted that Grid computing will be an important technology in the near to long term (indeed it can be credibly argued that it is already a very important technology to a select few), then wide spread acceptance will depend on making that technology easily accessible to general exploitation. In practice, this will not only involve interoperability and inclusiveness of key features, but, most importantly, it will require that non specialists be facilitated in constructing grid independent applications that run efficiently on the dynamic architecture that constitutes the Grid. The original problems of programming parallel and distributed systems still hold true: they are notoriously hard to program, since programmers usually have responsibility for synchronizing processes and for resource management. Solutions must be developed to free programmers from the low level details whose consideration gives rise to these problems. In effect, grid programming environments must evolve to a point where grid (and, in general, parallel) programs are freed from architecture details such as data locality, machine availability, inter-task synchronisation, communication topologies, task load-balancing, and fault tolerance in the same manner as present day sequential programmers are freed from explicit memory management, disk access protocols and process scheduling. At that point in the evolution of the Grid, the grid middleware will adopt the character of a grid operating system and many, if not all, of the issues that make grid programming difficult will migrate out of grid application programs. When this is achieved, the vision of hiding the Grid will have been realised and exploitation of the technology can begin in earnest.

Managing MPICH-G2 Jobs with WebCom-G

This paper discusses the use of WebCom-G to handle the management & scheduling of MPICH-G2 (MPI) jobs. Users can submit their MPI applications to a WebCom-G portal via a Web interface. WebCom-G then selects the machines to execute the application on, depending on the machines available to it and the number of machines requested by the user. WebCom-G automatically & dynamically constructs a RSL script with the selected machines and schedules the job for execution on these machines. Once the MPI application has finished executing, results are stored on the portal server, where the user can collect them. A main advantage of this system is fault survival, if any of the machines fail during the execution of a job, WebCom-G can automatically handle such failures. Following a machine failure, WebCom-G can create a new RSL script with the failed machines removed, incorporate new machines (if they are available) to replace the failed ones and re-launch the job without any intervention from the user. The probability of failures in a grid environment is high, so fault survival becomes an important issue