GRADE - Graphical Environment for Parallel Programming
by Péter Kacsuk and Sándor Forrai
GRADE is a graphical environment for parallel programming, based
on message passing, initiated in 1994 and developed in the frame
of European projects in co-operation with many partners from Hungary
and abroad.
Due to the inner difficulties of parallel programming (communication,
synchronisation, parallel debugging, visualisation and performance
analysis), efficient program development requires powerful graphical
tools. The main goal of our project is to develop a graphical
environment for efficient parallel programming, based on message
passing (GRADE). The developed programming tools integrated in
GRADE offer both the ease of use and the flexibility to complete
both simple and complex parallel applications. Using two of the
most popular message-passing interfaces, the software packages
PVM (Parallel Virtual Machine) and MPI (Message Passing Interface),
the execution of the developed applications in a heterogeneous
computing environment is allowed. The MPI (Message Passing Interface)
version of GRADE has been recently completed and it is under testing.
The first prototype of the GRADE was launched in 1997 and the
first version for distribution is expected by the end of 1998.
GRADE is based on the following tools as main components:
- GRAPNEL - graphical parallel programming language (developed by
the Laboratory of Parallel and Distributed Systems (LPDS) at SZTAKI)
- GRED - graphical editor (developed by LPDS), for parallel applications
development, which supports the syntax of GRAPNEL language
- GRP2C - pre-compiler (developed at the University of Miskolc,
Hungary), for C code generation (with PVM or MPI function calls)
from the graphical program
- TAPE/PVM -- monitoring tool for trace file generation (developed
at IMAG, Grenoble, France)
- DIWIDE - distributed debugger (developed by LPDS)
- PROVE - visualisation tool for trace file analysis (developed
by LPDS).
The program development cycle in GRADE is summarised as follows.
In the first phase the parallel program is designed by using the
graphical programming language GRAPNEL. In the next step the GRED
editor creates a .GRP file from the GRAPNEL program which contains
all the information necessary to restore the program graph for
further development and to compile the GRAPNEL program into C
and PVM/MPI code. Finally, the GRP2C pre-compiler additionally
creates other auxiliary files (including makefiles used by UNIX)
for building the executable file.
The C code generation and compilation is fully automated on every
host of the heterogeneous cluster of workstation. Based on the
executable file, the parallel program could be executed either
in debugging mode or in trace mode. In debugging mode the DIWIDE
distributed debugger provides commands to create breakpoints,
step-by-step execution of the program, animation, etc. In trace
mode a trace file is generated containing all the trace events
defined by the user. These events are visualised by the PROVE,
also used for performance analysis and for further optimisation.
The GRAPNEL (GRAphical Process’s NEt Language) has been developed
for designing distributed programs based on message passing programming
paradigm where the programmer can define processes which perform
the computation independently in parallel, and interact only by
sending and receiving messages among themselves.
The main purpose of the graphical presentation is to give a high
level of abstraction of the distributed programs where the key
points are the communication operations among the processes. In
addition, GRAPNEL provides the possibility of structured programming
with respect to the processes as program units.
In GRAPNEL language the most fundamental unit is the process which
manifests itself at two levels: Process Communication Level and
Process Internal Level. Every process has two graphical views:
one for describing the communication connections (ports and channels)
to the other processes (Process Communication Level or Application
level), and one for describing the inner structure of the process
(Process Internal Level or simply Process level).
The GRAPNEL programming environment - the GRED editor - supplies
the necessary support for both levels. A graphical window serves
for describing the whole application at the Process Communication
Level, representing the process graph of the application. Moreover,
for each process a new graphical window can be opened where the
inner structure of that process can be defined at the Process
Internal Level of the graphical representation.
GRAPNEL supports top to bottom parallel program design, based
on three hierarchical levels. Application level: the whole application
is described graphically, with respect to communication among
the processes. Processes, process groups, communication ports
and connections among the processes are defined graphically and
processes’ functionalities are hidden at this level. Process level:
the send and receive operations and their surrounding program
structures are defined graphically. Text level: Textual program
parts can be written in standard C (which can be done in any standard
UNIX editor), other textual languages (eg FORTRAN) will be supported
in future.
GRAPNEL can be useful for both non-professional (not experienced
with distributed systems) and professional programmers. The advantages
are given by the graphical environment: easy design, representation
and debugging of parallel applications.
Therefore, the main benefits of GRADE are as follows: graphical
programming environment for parallel application development (program
developers are not required to know the syntax of the message-passing
system), automatically generated and distributed executable program
code (even in heterogeneous computing environment), debugging
and visualisation of the developed parallel program in a fully
graphical programming environment.
As a conclusion, GRADE is a general purpose graphical programming
environment for parallel programming which can be applied successfully
in many application areas. As future activities, we intend to
develop parallel applications in the following fields: computational
fluid dynamics, numerical simulation, weather forecasting, pattern
recognition and document analysis, etc. Partners from industry
and academia, interested in parallel applications, are welcome.
GRADE has been installed successfully on the following hardware/software
platforms: Hitachi SR2201/HI-UX (Massively Parallel Processor),
SGI/IRIX 5, SGI Origin Series/IRIX 6, Sun Solaris/ SPARC 2.6,
Intel 2.0/Linux. Currently, GRADE is used by the following institutes:
University of Westminster, London; Institute of Computer Systems,
Slovak Academy of Sciences; Universidade Nova de Lisboa; Universidad
Autonoma de Barcelona; Technical University of Gdansk, Poland;
University of Miskolc, Hungary; University of Vienna; Polish-Japanese
Institute of Computer Techniques.
Up-to-date information about GRADE and the Laboratory of Parallel
and Distributed Systems of SZTAKI is available at http://www.lpds.sztaki.hu/.
Please contact:
Péter Kacsuk - SZTAKI
Tel: +36 1 329 7864
E-mail: kacsuk@sztaki.hu
Sándor Forrai - SZTAKI
Tel: +36 1 329 7864
E-mail: forrai@sztaki.hu
