Special
Issue on Parallel Programming Environments and Tools
Guest Editor: Peter Kacsuk
EDDEPPS: an environment for optimal
parallel software design
T.
Delaitre. M.J. Zemerly, G.R. Justo, J. Burgeois, S.C. Winter
Abstract.
This paper describes an environment for performance-oriented design of
portable parallel software. The environment consists of a graphical design tool
based on the PVM communication library for building parallel algorithms, a
state-of-the-art simulation engine and a visualization tool for animation of
program execution and visualization of platform and network performance measures
and statistics. The toolset is used
to model a virtual machine composed of a cluster of workstations interconnected
by a local area network. The simulation model used is modular and its components
are interchangeable which allows easy re-configuration of the platform. The
model is validated using experiments on the COMMSI benchmark from the Parkbench
suite, and a standard image processing algorithm with maximum errors of 1% and
10% respectively.
GRADE: a graphical programming environment
for multicomputers
P.
Kacsuk, G. Dózsa, T. Fadfyas, R. Lovas
Abstract.
To provide high-level graphical support for developing message
passing programs, an integrated programming environment (GRADE) is being
developed. GRADE currently provides tools to construct, execute, debug, monitor
and visualize message passing based parallel programs. GRADE offers the
programmer an integrated graphical user interface during the whole life-cycle of
program development and provides high-level graphical programming abstraction
mechanisms to construct parallel applications. The current version of GRADE can
generate C+PVM code but there is no theoretical obstacle to extend it for
supporting MPI [9]and FORTRAN. Those new features of the GRADE graphical
environment are described in the paper that enhanced GRADE towards a
professional parallel programming environment.
Using
DDBG to support testing and high-level debugging interfaces
J.C.
Cunha, J. Lourenço, V. Duarte
Abstract.
This paper describes our experience with the design and implementation of a
distributed debugger for C/PVM programs within the scope of the SEPP and HPCTI
Copernicus projects. These projects aimed at the development of an integrated
parallel software engineering environment based on a high-level graphical
parallel programming model (GRAPNEL) and a set of associated tools supporting
graphical edition, compilation, simulated and real parallel execution, testing,
debugging, performance monitoring, mapping, and load balancing. We discuss how
the development of the debugging tool was strongly influenced by the
requirements posed by other tools in the environment, namely support for
high-level graphical debugging of GRAPNEL programs, and support for the
integration of static and dynamic analysis tools. We describe the
functionalities of the DDBG debugger and its internal architecture, and discuss
its integration with two separate tools in the SEPP/HPCTI environment: the GRED
graphical editor for GRAPNEL programs, and the STEPS testing tool for C/PVM
programs.
Integrated
static and dynamic analysis of PVM programs with STEPS
H.
Krawczyk, B. Wiszniewski, P. Kuzora, M. Neyman, J. Proficz
Abstract.
STEPS is a tool for structural testing of parallel software. It incorporates
static and dynamic tools and provides a visual interface to ease the process of
finding errors in processes running in parallel.
Input data to this tool are C programs with inter-process communication
implemented with standard PVM library calls. The version of the tool described
in this paper has been tested on Sun Microsystem machines running Solaris 2.4
and 2.5 operating systems. STEPS
works under X-Windows graphical environment and uses Motif user interface.
Performance
prediction of PARALLEL systems by simulation
E.
Luque, R. Suppi, T. Margalef, J. Sorribes, P. Hernández, E. César, M. Serrano,
C. Ortet, F. Cores, J. Falguera
Abstract.
The simulation of parallel systems is an alternative approach to classical
parallel system programming. This simulation provides performance prediction
results that allow the reduction of parallel program development time-scale.
Simulation requires accurate models of the parallel program, parallel
architecture and all real characteristics of the parallel system. This paper
describes a simulation environment of parallel systems that is included in a
parallel programming environment in
order to facilitate the parallel programming cycle of the user.
Hybrid
approach to task allocation in
distributed systems
L.
Hluchý, M. Dobrucký, J. Astalo
Abstract.
This
paper describes the hybrid approach to task allocation in distributed systems by
using problem solving methods of the artificial intelligence. For static mapping
the objective function is used to evaluate the optimality of the allocation of a
task graph onto a processor graph. Together with our optimization method also
augmented simulated annealing and heuristic move exchange methods in distributed
form are implemented. For dynamic
task allocation the semidistributed approach was designed based on the division
of processor network topology into independent and symmetric spheres.
Distributed static mapping (DSM) and dynamic
load balancing (DLB) tools are controlled by user window interface. DSM and DLB
tools are integrated together with software monitor (PG_PVM) in the graphical
GRAPNEL environment.
Mapping
and dynamic load-balancing strategies
for parallel programming
A.
Ripoll, M.A. Senar, A. Cortés, E. Luque
Abstract.
A fundamental issue affecting the performance of a parallel application
running on message-passing parallel system is the assignment of tasks to
processors in order to achieve the minimum completion time.
Tools for static and dynamic task assignment can be considered
complementary: static mapping tools compute an initial assignment of tasks on
processors while dynamic load balancing tools are used at execution time. In
this paper, we present a compilation-time two-stage mapping strategy (denoted as
CREMA: Clustering and Reassignment-based Mapping Algorithm) used for efficiently
mapping arbitrary programs (modelled as TIGs: Task Interaction Graph) onto
message-passing parallel systems with any topology. Moreover, we also present a
new fully distributed dynamic load balancing algorithm (denoted as DASUD:
Diffusion Algorithm Searching Unbalanced Domains) for load balancing among the
processors of an arbitrary interconnected network of processors. We include a
description of both strategies and the results obtained in their respective
evaluation.
Solving
the task scheduling problem using a parallel genetic algorithm implemented with GRADE
T.
Kalinowski
Abstract.
In this paper, we present a task-scheduling heuristic, based on parallel genetic
algorithm (PGA). The algorithm schedules parallel programs, represented as
directed acyclic graphs (DAGs), onto multi-processor systems with dynamic
interconnection networks (DINs) taking into account inter-processor
communication cost, link contention and changes of inter-processor connections.
The proposed solution combines two methods: list scheduling which is used for
constructing schedules and genetic
algorithms which drives exploration of the search space for the list algorithm.
The parallel genetic algorithm has been implemented on a cluster of workstations
in the GRADE environment.
Extending
GRADE towards explicit process
SYNCHRONISATION in parallel programs
M.
Tudruj, P. Kacsuk
Abstract.