The GRED graphical editor for the GRADE parallel program development environment

https://doi.org/10.1016/S0167-739X(98)00088-0Get rights and content

Abstract

In this paper, we describe a graphical editor GRED as a part of the integrated programing environment GRADE that is intended to support designing, debugging and performance tuning of message-passing programs running on a heterogeneous network of computers. The GRED editor hides the cumbersome details of the underlying low-level message-passing system (which can be either PVM or MPI) by providing visual abstractions but allows the programer to define local computations of the individual processes in C (or in Fortran in the future) independently from the visually supported process management and inter-process communication activities.

Visual representation of the critical (i.e. message-passing related) parts of the code can help the user in grasping the complex structure and run-time behavior of the whole parallel application, even if he or she is not an expert in the field of concurrent programing.

Introduction

As local area networks (LANs) have become a basic part of today’s computing infrastructure, more and more people encounter the possibility of exploiting the available computational power of a heterogeneous network of computers.

The most widely used paradigm for implementing applications on such distributed systems is the message-passing (MP) concept, which is expected to be the most common approach for the next few years. The main reasons for its popularity are the simplicity of the concept and the fact that MP paradigm closely corresponds the way in which data are actually moved around in a distributed memory computer; thus, MP libraries can be implemented very efficiently in such systems. Moreover, sequential languages (mainly C and Fortran) familiar to most application programers can be used to perform the bulk of the computation.

Although there are quite a few MP systems (e.g. PVM [1], MPI [2]) which make it possible to execute parallel programs in heterogeneous environments, the lack of proper (i.e. user-friendly) support for development of such applications prevents most of the potential users from dealing with concurrent programing at all.

To cope with the extra complexity of parallel programs arising due to inter-process communication and synchronization, we have designed a visual programing environment called GRADE. GRADE stands for Graphical Application Development Environment and its major goal is to provide an easy-to-use, integrated set of programing tools for development of general MP applications to be run in heterogeneous environments. The central idea of GRADE is to support each stage of the parallel program development life-cycle by an integrated graphical environment where all the graphic views applied at the separate stage are related back to the original graph that defines the parallel program and which is designed and edited by the user.

The first stage of the parallel program development life-cycle is the program design which is supported by the GRAPNEL (GRAphical Process NEt Language, [3]) language. In GRAPNEL, all process management and inter-process communication activities are defined visually in the user’s application. Low-level details of the underlying MP system are hidden. GRADE generates all MP library calls automatically on the basis of the visual code of GRAPNEL. Since graphics hide all the low level details of MP, GRADE is an ideal programing environment for application programers who are not experienced in parallel programing (e.g. for chemists, biologists, etc.).

GRAPNEL is not a completely graphical language-like ProGraph [4], rather a hybrid language where local computations of the individual processes can be defined in a traditional textual language like C or Fortran (currently, only C is supported) independently from the visually supported MP-related activities. This hybrid approach has several advantages. The first one is that due to the graphical nature of GRAPNEL the programer is not required to know the syntax of the MP library and hence novice users in the field of parallel programing can use GRADE. The second advantage is portability, that is, the same user application is able to run in different MP environments provided that GRADE can generate the code for those environments. GRADE can generate code for the two standard MP environments: PVM and MPI. The third advantage comes from the textual nature of GRAPNEL: any existing C code or C library function can be easily inserted in the GRAPNEL program which significantly facilitates the parallelization of existing sequential codes. Moreover, the program graph can be kept at reasonable size since those activities unrelated with parallelism do not require graph formulation. In any graph-oriented language one of the most important crieteria for usability is to keep the size of the program graphs at the level of the monitor screen in order to show them in a single window. Graphs bigger than that are difficult to grasp and edit, and hence they discourage the application programers to use them.

Compilation of GRAPNEL programs and distribution of the executables in a distributed heterogeneous environment consisting of different kinds of workstations or MP parallel computers are performed automatically. The programer does not have to worry about updating executables on each different computer whenever the design of the parallel program has changed (see Section 6).

Debugging and monitoring information is directly related back to the user’s graphical code during on-line debugging and post-mortem visualization of run-time behavior of the application. The main strength of the tools comprising GRADE is the very close integration of their graphical user-interfaces, that is, the user is not forced to change his/her view point in the different phases of the development cycle since the environment always provide the same high-level visual representation of the application program.

GRADE currently consists of the following tools as main components:

  • GRED: A graphical editor to design parallel applications. The editor supports the syntax of the graphical language GRAPNEL.

  • GRP2C: A precompiler to produce the C code with PVM [5] or MPI function calls from the graphical GRAPNEL program.

  • DIWIDE: A distributed debugger that supports systematic testing and debugging of concurrent programs based on collective breakpoints, macrosteps and replay [6].

  • PROVE: A visualization tool to analyze and interpret Tape/PVM1 trace file information and present them to the programer graphically [7].

  • Simulator: A parallel architecture simulator is also integrated for performance prediction purposes [8].

The rest of the paper is organized as follows. The graphical editor GRED is described in detail in 2 The GRED editor, 3 Application window, 4 Process window, 5 Text editor window follwed by a brief summary about code generation and distribution technique of GRADE. After comparing GRADE/GRED with related work some conclusions are given.

Section snippets

The GRED editor

The central tool of the GRADE environment is the visual editor which can be used to design and edit parallel applications in the GRAPNEL language.

The GRAPNEL programing model is entirely based on the MP paradigm. The programer can define processes performing computations independently and interacting only by sending and receiving messages. A process can be either a single unit, or a member of a process group. Both processes and process groups are defined visually as boxes. Process groups can be

Application window

This window is used to define the top level visual description of the parallel application. Processes, communication ports and connections among the processes must be defined graphically but the functionalities (i.e. the code) of the processes are hidden at this level. In other words, processes are viewed as black boxes and we are only interested in their inter-connection topology. Fig. 1 depicts a sample window of this type. It contains six main areas: Menubar, Toolbar, Zooming area, Canvas,

Process window

After finishing the definition of the communication layout of the application program in the application window, the next step is the definition of the internal structure of the component processes. The process window serves to graphically describe the MP-related parts of the control flow of individual processes as shown in Fig. 2 for the process buffer of Fig. 1. The point is that send and receive operations must appear graphically in the GRAPNEL code of each process. If a send or receive

Text editor window

Every graphical instruction (icon) defined in a process or in a graphical block window owns a piece of C text code. For example, the text code belonging to a receive icon is simply a list of a variables to store the data to be received. However, a text block icon may own an arbitrary long and sophisticated C code segment which may refer to data or functions defined in external C files or libraries. As a result, C code written earlier can be reused easily.

The text editor that is invoked by GRED

Compiling the GRAPNEL programs

The programer can save the code of his application into a so-called GRP file that contains all the information necessary to restore the graphical program in the GRED editor, or to produce the executables of the application. The executables are generated in two steps [10]. In the first step, the pure C code of the GRAPNEL program is generated by the GRP2C precompiler. Afterwards, a standard C compiler is invoked to produce the executable binaries from the C code.

As GRADE usually works in

Related work

A number of other visual programing environments have been developed for parallel applications (e.g. VPE [11], TRAPPER [12], EDPEPPS [13], HENCE [14], PSEE [15], Paralex [16]). Most of them are based upon the idea that nodes represent parallel computation, and arcs represent interactions (of some form) among nodes. The problem with the HENCE, Paralex and PSEE approaches is that they force computations to be split into separate processes when communications occur or when branching decisions

Conclusions and further work

The more people encounter the possibility of exploiting the available computational power of heterogeneous networks of computer, the more vital is the demand for high-level tools to assists the development of MP-based parallel applications. GRADE provides an integrated graphical programing environment where the user can develop his parallel program by using high-level tools and abstractions without worrying about the low-level details of MP primitives.

The graphical editor GRED fully supports

Acknowledgements

The work described in this paper was funded by EC Contract Number: CIPA-C193-0251, CP-93-5383 and by the National Science Research Fund (OTKA) Contract Number: F022105 and currently continued in the framework of the following five projects: Hungarian–German S&T Project D-62/96 and Hungarian–Greek S&T Project GR-25/96, Hungarian–Portuguese S&T Project P-12/97, Hungarian–Spanish S&T Project E-17/97.

Peter Kacsuk is the Head of the Laboratory of the Parallel and Distributed systems in the Computer and Automation Research Institute of the Hungarian Academy of Sciences. He received his MSc and doctorate degrees from the Technical University of Budapest in 1976 and 1984, respectively. He received the kandidat degree (equivalent to PhD) from the Hungarian Academy in 1989. He habilitated at the University of Vienna in 1997 where he is a private professor. He is an appointed visiting professor at

References (19)

  • P. Kacsuk et al.

    Designing parallel programs by the graphical language GRAPNEL

    Microprocessing and Microprograming

    (1996)
  • T. Delaitre et al.

    A graphical toolset for simulation modelling of parallel systems

    Parallel Computing

    (1997)
  • A. Geist, A. Beguelin, J. Dongarra, W. Jiang, R. Manchek, V.S. Sunderam, Parallel Virtual Machine – A Users’ Guide and...
  • W. Gropp, E. Lusk, A. Skjellum, Using MPI: Portable Parallel programing with the Message-passing Interface, MIT Press,...
  • P.T. Cox, H. Glaser, S. Maclean, A visual development environment for parallel applications, in: Proc. IEEE Symp....
  • D. Drótos, P. Kacsuk, GRAPNEL to C translation in the GRADE environment, Computers and Artifical Intelligence, accepted...
  • P. Kacsuk, Macrostep-by-macrostep debugging of message-passing parallel programs, in: Proc. 10th IASTED Int. Conf. on...
  • P. Kacsuk, G. Dózsa, T. Fadgyas, R. Lovas, GRADE: a graphical programing environment for multicomputers, Computers and...
  • R. Suppi et al.

    Simulation in parallel software design

    Parallel and Distributed Systems Networks

    (1998)
There are more references available in the full text version of this article.

Cited by (22)

View all citing articles on Scopus

Peter Kacsuk is the Head of the Laboratory of the Parallel and Distributed systems in the Computer and Automation Research Institute of the Hungarian Academy of Sciences. He received his MSc and doctorate degrees from the Technical University of Budapest in 1976 and 1984, respectively. He received the kandidat degree (equivalent to PhD) from the Hungarian Academy in 1989. He habilitated at the University of Vienna in 1997 where he is a private professor. He is an appointed visiting professor at the University of Westminster, part-time associate professor at the University of Miskolc and full professor at the Kandó Kálmán Colege of Technology. He served as visiting scientist or professor several times at various universities of Austria, England and Japan. He published three books, two lecture notes and more than 90 scientific papers on parallel logic programing, parallel computer architectures and parallel software engineering tools.

Tibor Fadgyas studied mathematics at Lóránd Eötvös University in Budapest. He received his MSc degree in mathematics in 1982. He is currently research fellow at the Computer and Automation Research Institute of the Hungarian Academy of Sciences. He participated in several international research projects in the field of parallel programing and visualisation. His main research interest fields are in parallel algorithms, parallel programing and visualisation.

Ròbert Lovas received his MSc degree in 1998 from the Faculty of Electrical Engineering and Informatics of the Technical University of Budapest. He is currently research fellow at the Laboratory of Parallel and Distributed Systems at the Computer and Automation Research Institute of the Hungarian Academy of Sciences. He began his PhD studies at the same university in 1998. In the last two years of his university studies he participated in several international research project of the Laboratory of Parallel and Distributed Systems.

Gàbor Dòzsa received his MSc degree in computer science at the Lóránd Eötvös University of Sciences in Budapest. He is currently the deputy head of the Laboratory of Parallel and Distributed Systems at the computer and Automation research Institute of the Hungarian Academy of Sciences. His research interests include concurrent and parallel programing distributed systems and visual parallel programing languages.

View full text