Grid Programming Models: Author: Craig Lee and Domenico TaliaPresenter: Tuan Cameron

Current Tools, Issues and Directions

IntroductionThe main goal of this paper is to:

Discuss the major issues facing grid programming

Survey the common programming models being used and proposed in the grid environment

Discuss programming techniques and approaches that could be used to resolve the major issues.

Grid Programming Issues Portability, Interoperability, and Adaptivity Discovery Performance Fault Tolerance Security Program Meta-Models

Grid Programming Issues Portability, Interoperability, and

Adaptivity Portability is a necessary prerequisite for coping with

dynamic, heterogeneous configurations.

The notion of using different but equivalent codes and services implies interoperability of programming model implementations.

A grid program should be able to adapt itself to different configurations based on available resources.

Grid Programming Issues Discovery

Discovery is an important issue because grid codes will need to discover suitable hosts on which to run

Programming environments and tools must be aware of available discovery services and offer a user explicit or implicit mechanisms to exploit those services

Grid Programming IssuesPerformance

Performance becomes an issue since grids present heterogeneous bandwidth and latency hierarchy that can make it difficult to achieve high performance and good utilization of co-scheduled resources.

In a shared environment, quality of service will become increasingly necessary to achieve reliable performance for a given programming construct on a given resource configuration.

Grid Programming Issues Fault Tolerance

As the number of resources involved increases, so does the probability that some resource will fail during the computation.

Grid applications must be able to check run-time faults of communication and/or computing resources and provide actions to recover or react to faults.

Grid Programming Issues Security

Since grid codes will commonly run across multiple administrative domains using shared resources such as networks, security become an issue.

A mechanism that provides authentication and privacy must be integral to grid programming tools.

Grid Programming Issues Program Meta-Models

Complete grid programming will require models about the programs themselves.

Grid Programming models such do everything

current programming models do on a grid scale.

The application of enhancements, however, will be complicated by the distributed, heterogeneous nature of the grid.

Grid Programming Tools Shared-State Models Message-Passing Models RPC and RMI Models Hybrid Models Peer-to-peer Models Frameworks, Component Models and Portals

Grid Programming Tools Shared-State Models

Shared-State programming models are typically associated with tightly coupled, synchronous languages and execution models that are intended for shared memory machines or distributed memory machines with a dedicated interconnection network that provides very high bandwidth and low latency.

JavaSpaces is a Java-based implementation of the Linda tuplespaces concept, in which tuples are represented as serialized objects.

In a publish/Subscribe system, publishers post messages to an intermediary Broker and subscribers register subscriptions with that broker.

Grid Programming Tools Message-Passing Models

In message-passing models, processes run in disjoint address spaces and information is exchanged using message passing of one form or another.

MPI and Variants – The Message Passing Interface(MPI) is a widely adopted standard that defines a two-sided message passing library with matched sends and receives, that is, well-suited for grids. Examples includes MPICH-G2, MagPIe, PACX-MPI and Stampi

One-sided Message Passing – In this case a send operation does not necessarily have an explicit receive operation. eg. Nexus

Grid Programming Tools RPC and RMI Models

RPC and RMI Models structure the interaction between sender and receiver more as a language construct, rather than a library function call that simply transfers an uninterpreted buffer of data between points.

Grid-enable RPC – GridRPC is an RPC model and API for grids.

Java RMI – Java Remote Method Invocation enables a programmer to create distributed Java-based applications.

Grid Programming Tools Hybrid Models

Applications that run multi-threaded within a shared-address space, and also by passing data and control between machines are Hybrid models

OpenMP and MPI – OpenMP is a library that supports parallel programming in shared-memory parallel machines.

OmniRPC - OmniRPC was specifically designed as a thread-safe RPC facility for clusters and grids.

MPJ – Message-passing Java makes multithreading, RMI and message-passing available to application builders.

Grid Programming Tools Peer-to-peer Models

Peer-to-peer (P2P) computing is the sharing of computer resources and services by direct exchange between systems.

Peer-to-peer computing takes advantage of:

Existing desktop computing power Networking connectivity

An example of an open generalized peer-to-peer protocol is JXTA.

Grid Programming Tools Frameworks, Component Models and

PortalsCactus CORBA CoG KitLegion Component Architecture Portal Web Service Models Coordination Models

Advanced Programming Support

Traditional Techniques Data-driven Techniques Speculative or Optimistic Techniques Distributed Techniques Grid-Aware I/O Advanced Communication Services Security Fault Tolerance Program Metamodels and GridAware Runtime

Systems

Advanced Programming Support

Traditional Techniques There are a number of traditional performance

enhancing techniques that can be brought to bear in grid codes.

Overlapping computation with communication Shadow arrays Aggregated communication Compression Protocol tuning

Advanced Programming Support

Data-driven Techniques Data-driven programming techniques can facilitate a

more asynchronous, loose coupled execution model.

Both Workflow and Stream programming are instances of this model.

Advanced Programming Support

Speculative or Optimistic Techniques Speculative or optimistic technique is another

method of producing a more asynchronous, loosely coupled execution.

The goal is to control the level of optimism such that the benefits of loosely coupled execution are maximized while the overhead of wasted computation is minimized.

Advanced Programming Support

Distributed Techniques Distributed techniques can achieve very high

aggregate bandwidths between local data and processing through the distribution of processing over data.

Eg: Grid Datafarm Architecture which is designed to exploit access locality by scheduling programs across a large-scale distributed diskfarm that has processing close to the storage.

Advanced Programming Support

Grid-Aware I/O While I/O systems may concentrate on the movement

of data , they can certainly have a large effect on how programs are written.

Advanced Programming Support

Advanced Communication Services Advanced Communication Services is essentially any

type of semantics associated with communication beyond the simple, reliable unicast transfer of data from point A to point B, or even the multicast of data one to many.

Motivation: The need to become topology-aware to achieve better

performance The need for fundamentally different communication

properties Can be classified into several categories:

Augmented communication semantics Collective operations Content-based and Policy-based Routing Communication scope

Advanced Programming Support Security

Grid applications may want authentication, authorization, integrity checking and privacy.

Problems: Signing and checking certificates on an RPC

represents an overhead that must be balanced against the amount of work represented by the RPC

Solution: Use trusted domain that could limit per-RPC security

overheads in favor of the one-time cost of establishing the domain

Advanced Programming Support

Fault Tolerance Reliability and fault tolerance in grid programming

models/tools are largely unexplored, beyond simple check pointing and restart.

The issue here, is how to make grid programming models and tools inherently more reliable and fault tolerance.

It should be possible to: Detect the fault Propagate the notification of the fault to relevant sites Take action to either recover or limit the effects of the

faults Event Models may be used to make grid

programming models and tools more reliable and fault tolerant.

Advanced Programming Support

Program Metamodels and GridAware Runtime Systems Regardless of how grids are ultimately deployed, they

will consist of components and services that are either persistent or can be instantiated.

Some of these components and services will become widely used and commonly available. Hence, many applications will be built through the composition of components and services.

Meta-models can be used to define a component’s characteristics and properties in effect allowing composition to be accomplished automatically.

ConclusionA successful grid programming model

would need to have the following:PortabilityInteroperabilityAdaptivityThe ability to support discoverySecurityFault toleranceGood performance