RAMPA - CASE for portable parallel programs development
V.A.Krukov, L.A.Pozdnjakov, I.B.Zadykhailo
Keldysh Institute of Applied Mathematics, Moscow
Table of contents
2. Purpose and composition of the RAMPA system
6. The debugging and monitoring tools
At the present time the main way of increasing the computer ower is the designing multi-processor computer systems with distributed memory. In the world there are a large number of such projects (e.g. Tera 3D, CM-5, KSR1, Paragon) aimed to the realization of the teraflop computer power up to the end of the decade. All of these systems are multi-processor systems with distributed memory consisting of thousands of processors. The design of applications software for such distributed systems meets a number of very serious troubles.
The concurrent program development needs using or creating the appropriate computing methods. To achieve the require efficiency it is necessary to go many times from the algorithm specification to the program written in programming language. And this way is much more complicated for the Parallel Computers then it is for traditional ones.
The lack of availability of concurrent algorithms and programs which the programmer could use in the work aggravates the problems arising by concurrent programs development. In this connection there is a pressing requirement to use huge banks of programs and algorithms written in sequential programming languages.
There are pure psychological problems connected with human perception of parallel algorithms. A man more naturally deals with the sequential algorithms and programs. So the transition to the distributed systems using makes the applications programmer's work much more complicated. Moreover it strongly reduces the pace of program development. That's why it is desirable to give a programmer an opportunity to use a traditional sequential programming languages, which are possibly modified for the increasing efficiency of the automated algorithm paralleling.
The concurrent programs worked out with language facilities which avaliable for the distributed systems require serious efforts for mapping the programs not only on computers with different architectures (sequential, SIMD processor arrays, MIMD shared memory machines), but also on the same computers with another configuration. Linking the concurrent program with using simple modules, accumulating the bank of common concurrent programs and modules are the problems to investigation.
Finally it is necessary to outline the lack of adequate
techniques and facilities for concurrent programs debugging and
monitoring. Also there are not avaliable instrumental systems,
which allow to organize the paralleling technique teaching the
wide number
of specialists.
To get over difficulties pointed above and to make convinient and effective using the perspective computer systems with massive parallelism, the investigations of the computer aided system for portable concurrent programs designing (the RAMPA system) have been started at Keldysh Institute of Applied Mathematics Russian Academy of Sciences.
The RAMPA system should integrate three different approaches to constructing the programming languages for the distributed computers. These approaches based on:
The system RAMPA is designed to create, debug and monitor
parallel programs for MIMD distributed-memory machines. The main
programming languages are Fortran DVM and Norma [4]. Programs in
these languages can be effectively mapped on various distributed
systems. Using the appropriate compilers such programs will be
mapped on computers with different architectures (sequential,
SIMD processor arrays, MIMD shared memory machines). These
programs can be easily used as modules for constructing more
complex programs.That will significantly reduce the development
costs of new programs
and will result in establishing widely used banks of parallel
algorithms.
The system will also allow the development of programs with Fortran GNS, Fortran 77 and C languages, extended with tools from specially made library for parallel programs support. But that will make programs development more labour-consuming and programs portability much lower.
Above that, using instrumental computer (for instance IBM PC) the system could simulate the program execution for computers with different architecture and evaluate the efficiency of parallelism. The system also could help a programmer to rewrite sequential program into parallel one. Thus the system could be used for training in parallel programming.
The system under developing includes the Fortran DVM, NORMA and Fortran GNS compilers converting the program into extended Fortran 77. The system also envolves the libraries LIB-DVM and LIB-GNS for concurrent programming support and debug and monitor tools.
Fortran GNS is Fortran 77 extended in correspondence with proposals of C.A.Thole [3], based on abstract GENESIS-machine concept. According to this concept the user's task is a set of sub-tasks which are dynamically created on the specified processors of distributed system. These sub-tasks communicate among themselves by sending and receiving messages in any of the three modes: synchronous, asynchronous and nowait.
The abstract GENESIS-mashine conception is realized as a LIB-GNS library and this makes it available both for the C and Fortran 77 programs. The following approach to the separation of duties between the library and the configuration description language (which is usually applicated for tasks mapping onto processors of distributed system) was accepted by this library realization. The library should allow to map programs onto different processors of some virtual parallel machine (GNS-machine) and should organize the communications between them. The configuration description language should allow to set an effective mapping of the virtual parallel machine onto available hardware.
The virtual parallel machine is a aggregate of rectilinear virtual processor arrangements. When the virtual machine is mapped onto a physical machine, several virtual processors can be mapped onto a single physical processor. This simplifies adaptation of programs for a specific configuration and at the same time increases our capabilities in program debugging.
The Fortran GNS language provide the following basic features for parallel application programming.
Initialization and Termination of whole application
Tasks
Message passing
Reduction functions
The Fortram DVM compiler will produce the Fortran 77 program, which will be extended with the library LIB-DVM tools. That library in its turn is the superstructure of the LIB-GNS library.
Norma is a non-procedural language designed for numerical algorithms of solving mathematical physics problems using difference methods.
The basic idea of this language is to use the description of the problem in the form of computational formulae obtained by applied specialist as input information to run computations.
Thus Norma allows applied mathematicians to formulate their problems in their usual terms. The computational process for specific hardware architecture (parallel, vector, etc.) is organized by the translator from Norma.
Research during development and implementation of the non-procedural Norma language shows that program synthesis for the grid methods solutions of the problems of mathemaical physics can be done under practically acceptible restrictions.
Currently there exist the versions of the translator from Norma into sequential FORTRAN 77 and into vector-parallel Fortran VP (extension of Fortran 8X).
The Norma programming system has been used for applications in mathematical physics, including 3-D viscous incompressible fluid flow problems.
The debugging and monitoring tools are used in the following three modes:
A programmer has to spend much more effort to debug a parallel program than a sequential one. It may be explained by specifics of human perception of parallel algorithms as well as a nondeterministic nature of parallel program execution. The same problems have for a long time been a challenge for designers of OS and real-time systems. Therefore it is only natural to borrow from their arsenal of debugging techniques such as tracing, the corresponding tools for automated analysis of traces and the tools for automated analysis of fixed states of program execution. Also important are visualization facilities for graphic representation of the structure of parallel programs, and their message exchange characteristics.
Debugging tools should make it possible to repeatedly run a parallel program with the same results in order to eliminate nondeterministic behavior of the program during error localization.
The following traditional interactive debugging tools will be implemented: the breakpoints setting, the visualization of values of the marked variables, etc.
The monitoring facilities can be treated as an integrated part of debugging tools since they enable programmers to gain a better understanding of his program. Among these facilities are statistics gathering software and profiling software.
By simulation of the concurrent program execution using instrumental computer the user will be able to debug Fortran DVM, NORMA, Fortran GNS programs and to debug programs written in Fortran 77 and in C languages, which extended with the LIB-GNS library tools.
Above that, using the instrumental computer for debugging could help a programmer to rewrite his sequential program into parallel one written in Fortran DVM language. In this case adding control instructions to the program will not influence on correctness of program execution but it will only effect on the estimation of program execution time.
For providing such mode the compiler will prepare program in a special manner. By the program simulation it will allow to make dynamic analysis of statement relations and to use this analysis for choosing the control instructions correctness and for estimating synchronizing and message passing time. By the simulation the user will be able to take exhaustive information about his wrong or non-optimal instructions and information about the program executing, which help him with paralleling the program.
The possibility of gradual paralleling the program with the guaranted correctness of its execution not only makes essentially easier this process but also in some cases allows to limit oneself estimating the concurrent program performance after mapping the computations onto processors (e.g. in case of using or creating the appropriate computing methods).