ERCIM News No.36 - January 1999
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 Processs 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/.
Péter Kacsuk - SZTAKI
Tel: +36 1 329 7864
Sándor Forrai - SZTAKI
Tel: +36 1 329 7864