ASSIST e

Programmazione Grid

Marco VanneschiDipartimento di Informatica

Università di Pisa

Gruppo Assist, gennaio 2003• Marco Aldinucci• Sonia Campa• Pierpaolo Ciullo• Massimo Coppola• Marco Danelutto• Silvia Magini• Paolo Pesciullesi• Alessandro Petrocelli• Edoardo Pistoletti• Laura Potiti• Roberto Ravazzolo• Massimo Torquati• Marco Vanneschi• Corrado Zoccolo

Segretaria del Gruppo:

Simona Moimoi@di.unipi.it050 - 2212718

Obiettivo

• Caratteristiche base di ASSIST e possibili evoluzioni

• Relazione con le esigenze della programmazione di griglie computazionali

• Componenti e oggetti

• Applicazioni ASSIST + CORBA

High-performance Grids: high-speed networks of … of clusters of … SMP/MPP ….

Uniform approach toUniform approach to

distribution + parallelismdistribution + parallelism

• Distributed Distributed Supercomputing, Supercomputing,

• On demand HPC,On demand HPC,

• Data Intensive Data Intensive Computing,Computing,

• Collaborative ComputingCollaborative Computing

• Grid aware ComputingGrid aware Computing• ……

• Parallel Programming as the basic methodology to understand and to realize development tools

• to be characterized wrt the specific features of Grids

• to be rendered consistent with the programmability, compositionality and reuse standards

Uniform approach to distribution + parallelism: why ?

• Not so obvious that distinct parallel components / objects can be efficiently allocated to distinct nodes– Optimization of computational and data resources

– Evolution of networking and communication technology

• Different versions of the same applications can be produced acting on parallelism degree, parallelism forms, multiplicity of components / objects

• Not necessarily parallelism inside a component / object is fine grain; e.g. coarse grain farms

• Adaptive applications

• Data intensive applications– Interfacing data management to computations

Component-structured application

Abstraction of Memory Hierarchy

Data intensive applications

Abstraction of Shared Objects

Scheduling and configuration of complex, high-volume data flows through multiple levels of hierarchy.

ASSIST

Structured Parallel Programming

+

High-performance Components

+

Objects

Results of ASI-PQE project and Agenzia 2000

• ASSIST version 1.0 for homogeneous and heterogeneous clusters (DI-UniPi, Synapsis)– A subset of ASSIST-CL– Support based on ACE + Distributed Shared Memory– Object-based design of compiler and support– Task-code and AssistLib: lower levels of programmability

• Integration of scientific libraries in ASSIST support (CPS-CNR, Na)

• AssistConf: a first tool for Grid configuration on top of Globus (ISTI-CNR, Pi)

• Demonstration on computational chemistry applications (UniPg)and benchmarking (PoliMi)

ASSIST Coordination Language

(ASSIST-CL )

• Programs as general graphs whose nodes are parallel modules and/or sequential modules

Compositionality through streams

Data-flow behaviour + state + nondeterminism

Programs reusable as nodes of other programs

• Programs could also be expressed as “SkIE graphs” (pipeline,

farm, loop skeletons), where the composed modules are

ASSIST-modules

External Objects

Application structuring through Parallel Components and Objects

M3

Component: Parallel (or sequential) module

Input

streams

Output stream

M5

s34M4

s25

s45 s54

M1 s13

M2s23

• Global variables

• Shared memory

• Files and I/O

• Web

• CORBA

• ASSIST modules

• . . .

Some abstractions are present in ASSIST 1.0, others will be realized in Grid projects

Graphs and streams

• ASSIST networks of components operate on streams

• DAG as particular case (stream length = 1)

– co-scheduling is expressed by program or implemented at the support level

– in ASSIST DAGs could also be executed in pipeline

• Importance of multiple streams

– data intensive computations,

– interactive computations,

– calculation / communication overlapping,

– …

Formalisms for ASSIST programs as a graph

M1

M2

M3

M4

M5

s13

s23

s34

s25

generic main (. . .) stream int s13; stream int [N][N] s23; stream int [N][N] s34; stream int s25;

M1 (ouput_stream s13);M2 (output_stream s23, s25);M3 (input_stream s13, s23; output_stream s34);M4 (input_stream s34);M5 (input_stream s25);

• Graphs with general structure

• Compositionality through streams (i.e. sequences of typed data)

Current, experimental syntax/semantics;

the FIRB GRID.IT project will consider

• IDL-compliant

• CCA-compliant

• scripting languages

• . . .

Parallel Module (parmod): parallel component in ASSIST

Set of Virtual Processors with names

VP VP VP

VP VP VP

VP VP VP

External Objects

Output streams

. . .

Input streams

. . .Other

ModulesOther

Modules

Several distribution and collection strategies, nondeterminismDistributed internal state

Parallel components + objects

• Not only a classical approach to software reuse

• Often, external objects are simpler and/or more performant solutions to programming problems

– e.g. data distribution, load balancing, memory capacity, …

– dynamic data structures (shape and size not known until run-time)

• In turn, parallel ASSIST programs may be used as objects

C1

C2

Ci

Cn

S1 S2 Sj Sm

. . .

. . . . . .

Components and streams

External Objects

. . .

An example of complex application: data mining C4.5 expressed as a parallel Divide & Conquer

TClient

Test

Divide

Conquer

training set TS, decision tree

P1

PN

For load balancing reasons,

during some phases the same parmod (Divide) works in a data-parallel manner,

in other phases in a farm-like manner,

in other phases …

An example of adaptive strategy expressed at the programming level.

Data intensive computations in ASSIST

Object (possibly high-bandwidth) Abstraction of high-performance objects can be implemented by ASSIST parmod(s) with proper interface

(expressed in ASSIST or another formalism)

VP VP VP

VP VP VP

VP VP VP

Input Section

Output Section

ASSIST module (parallel component)

External Object Interface (possibly parallel)

Data intensive computations in ASSIST

1. High-performance abstaction of objects (e.g. complex memory hierarchies) can be implemented by parallelism (see previuos slide).

2. In some cases, it could be more efficient to interface external objects through the Input/Output sections of parallel components: an ASSIST extension to be studied.

3. The combination of techniques 1 and 2 might be very powerful.

Input Section, Virtual Processors, Output Section of parmod

II

Input Section

s13

s23

OO

Output Section s34

VPVP

Virtual Processors

• Management of input streams according to the proper strategy (data-flow, nondeterministic)

• Possible pre-elaborations (filter) and operations

• Distribution of received values to VPs

For each output stream:

• Output strategies of values computed by VPs

• Possible post-elaborations and operations

External Objects

internal pipelining

Input Section: data distributions

• On demand• Broadcast• Scatter• Multicast

Input/Output sections could be optimized for external objects interfacing

data management, memory hierarchies

minimizing bottlenecks (pre/post-processing)

in addition to VP parallel access to objects

security and fault tolerance

+ nondeterminism and “on the fly” processing of stream data

Optimizations, scheduling, mapping, …(FIRB GRID.IT project)

• New research issues [e.g.: GrADS] are to be dealt with:– challanges in static + dynamic compiler design– importance of a “constraint-based” programming model

• New impacts on middleware– new light-weight middleware– exploiting Knowledge Discovery in Grid databases

• More that one level of programmability?

• Expressive power for dynamic behaviours.

ASSIST and

CORBA

ASSIST e CORBA

• Un programma ASSIST può importare ed esportare servizi tramite lo standard CORBA.

• ASSIST vede CORBA come un oggetto esterno

• L’importazione/esportazione avviene all’interno delle procedure (proc) di un qualsiasi modulo sequenziale o parallelo.

• L’utilizzo di CORBA all’interno di un programma ASSIST non richiede particolari accorgimenti sintattici.

Cliente in ASSIST

• Il Server CORBA esporta un servizio che si può utilizzare in un programma ASSIST.

• Il Cliente è un modulo ASSIST (sequenziale o parallelo) che:

• inizializza un ORB

• si procura un object Reference

• invoca il metodo del server.

Server CORBA

Client ASSIST

Cliente parallelo

• Il programma ASSIST ottiene i dati di input dal server CORBA - GUI

• Il programma ASSIST esegue N-body e visualizza i dati tramite il server CORBA.

• L’interazione avviene quindi contemporaneamente con il calcolo

GUI Server CORBA

client loopN-body

Programma ASSIST

Esportazione di servizi• Ogni applicazione F scritta in

ASSIST, con un INPUT (A) ed un OUTPUT (B),

puo’ essere esportata come

servizio attraverso CORBA,

aggiungendo all’applicazione

un modulo che svolga le

funzioni del Server.

• Il Server esporta il metodo do_F con l’INPUT e l’OUTPUT dell’applicazione F.

serverF

Programma ASSIST

A

B

Programma ASSIST disponibile come servizio CORBA

Esempio di esportazione di servizi• SPT: parmod ASSIST • Server: modulo ASSIST che si interfaccia con il mondo esterno mediante CORBA.

• Il server puo’ essere

generato in modo

automatico a partire

dal codice ASSIST.

• Client: programma scritto in un qualsiasi linguaggio

supportato da CORBA; • invoca il metodo do_spt esportato dal server.

serverspt

Programma ASSIST

A

B

Client con interfaccia CORBA

parmodone parmod

array

B = do_SPT(A)

The end