No full-text available
To read the full-text of this research,
you can request a copy directly from the author.
A Graphical Retargetable Parallel Programming Environment and Its EfficientImplementation (dissertation)
Abstract
This dissertation addresses the problem of facilitating the development of efficiently executing programs for multiple-instruction multi-datastream (MIMD) parallel computers. The family of MIMD parallel computer architectures is the most flexible and most widely applicable means of meeting requirements for very high performance computation. It is widely accepted, however, that current methods of preparing programs for these systems are inadequate and are the primary bottleneck for attainment of these machines'' potential. It is difficult to write programs which are both correct and efficient even for a single MIMD parallel architecture. A program which is efficient in execution on one member of this architecture class is often either not portable at all to different members of the architecture class, or if portability is possible, the efficiency attained is usually not satisfactory on any architecture. The conceptual basis of the approach we have taken to providing a solution for the problem of programming MIMD parallel architectures is based upon raising the level of abstraction at which parallel program structures are expressed and moving to a compositional approach to programming. The CODE 2.0 model of parallel programming permits parallel programs to be created by composing basic units of computation and defining relationships among them. It expresses the communication and synchronization relationships of units of computation as abstract dependencies. Runtime determined communications structures can be expressed. Ready access to these abstractions is provided by a flexible graphical interface in which the user can specify them in terms of extended directed graphs. Both ease of preparation of correct programs and compilation to efficient execution on multiple target architectures is enabled. The compositional approach to programming focuses the programmer''s attention upon the structure of the program, rather than development of small unit transformations. In the CODE 2.0 system, the units of computation are prepared using conventional sequential programming languages along with declaratively specified conditions under which the unit is enabled for execution. The system is built upon a unique object-oriented model of compilation in which communication and synchronization mechanisms are implemented by parameterized class templates which are used to custom tailor the translation of abstract specifications in communication and synchronization to efficient local models. The attainment of the goals of the research is measured in the following ways. There have been several uses of the CODE 2.0 system by casual users in parallel programming classes. The results are uniformly positive; the programs which are developed are simple and easy to read, and execute at least as efficiently as programs written in conventional parallel languages. Experimental measurement of the execution behavior of benchmark programs has shown that the executable code generated
Software engineering is a complex process that typically follows a number of distinct phases such as requirements engineering, system analysis and design, implementation and testing. Throughout the process different skills, business aspects, and levels of detail are required to complete each phase, and the form of presenting and conveying information changes to improve understanding. This is a dynamic process that often crosses phase boundaries, and requires that people of different background or skills communicate effectively and unambiguously. Writing as visible speech transforms our thoughts into nonperishable media, and any reader trained in the conventions can reconstruct the meaning. It has been proven that visual structures and relationships are easier to reason about than similar linguistically described structures [18]. The diagram became indispensable as a medium of knowledge representation and exchange of ideas and concepts among interested parties, even when they do not speak the same language. It can be grasped quickly, and navigated easily by following the visual clues between the information vortices.
Thesis (Ph. D.)--University of Maryland at College Park, 1996. Thesis research directed by Dept. of Computer Science. Includes bibliographical references (leaves 117-129).
Debugging is a process that involves establishing relationships between several entities: The behavior specified in the program, P, the model/predicate of the expected behavior, M, and the observed execution behavior, E. The thesis of the unified approach is that a consistent representation for P, M and E greatly simplifies the problem of concurrent debugging, both from the viewpoint of the programmer attempting to debug a program and from the viewpoint of the implementor of debugging facilities. Provision of such a consistent representation becomes possible when sequential behavior is separated from concurrent or parallel structuring. Given this separation, the program becomes a set of sequential actions and relationships among these actions. The debugging process, then, becomes a matter of specifying and determining relations on the set of program actions. The relations are specified in P, modeled in M and observed in E. This simplifies debugging because it allows the programmer to think in terms of the program which he understands. It also simplifies the development of a unified debugging system because all of the different approaches to concurrent debugging become instances of the establishment of relationships between the actions.
The unified approach defines a formal model for concurrent debugging in which the entire debugging process is specified in terms of program actions. The unified model places all of the approaches to debugging of parallel programs such as execution replay, race detection, model/predicate checking, execution history displays and animation, which are commonly formulated as disjoint facilities, in a single, uniform framework.
We have also developed a feasibility demonstration prototype implementation of this unified model of concurrent debugging in the context of the CODE 2.0 parallel programming system. This implementation demonstrates and validates the claims of integration of debugging facilities in a single framework. It is further the case that the unified model of debugging greatly
simplifies the construction of a concurrent debugger. All of the capabilities previously regarded as separate for debugging of parallel programs, both in shared memory models of execution and distributed memory models of execution, are supported by this prototype.
This paper reports on experimental research on extraction of coarse grain parallelism from constraint systems. Constraint specifications are compiled into task level procedural parallel programs in C. Three issues found to be important are: (i) inclusion of operations over structured types as primitives in the representation, (ii) inclusion of modularity in the constraint systems, and (iii) use of functions in the constraint representation. The role of these issues is described. The compilation process focuses on determining the parallel structure defined by the constraints and creates a parallel program in the format of the CODE 2.0 parallel programming environment. The compilation algorithm is described. An example compilation of a constraint system defining a simple numerical algorithm to a parallel C program is given and performance results are reported. Directions for future enhancement of the compilation process are suggested. 1 1 Introduction and Background Interest in parall...
ResearchGate has not been able to resolve any references for this publication.