PM2(ID:2528/)Parallel Modula-2References: Introduction Portability of parallel programs is a major problem in large-scale parallel processing. Current programming methods often result in efficient implementation of programs on only a single category of parallel architectures. After assessing the suitability of an application for a specific architecture, it will normally be necessary to reprogram that application extensively to allow the exploitation of parallelism by the parallel system under consideration. Programming tools for a parallel computer come in two basic flavours. They allow exploitation of either implicit or explicit parallelism. We do not know of any parallel programming environment that efficiently supports both paradigms. Implicit parallelism depends on the detection of parallelism by a concurrentizing compiler. By providing the programmer with a sequential abstract machine, programming a parallel system should not be very different from programming a sequential machine. Unfortunately, this advantage is not realized in practice. To achieve sufficient speed-up the programmer still has to be aware of the parallel target computer and techniques to maximize the exploitation of parallelism. Dataflow languages, such as SISAL (Stream and Iteration in a Single-Assignment Language) [OLDEH88], attempt to provide a more general approach by adopting functional semantics. Dataflow languages are motivated by the inherent parallelism in computer programs at the level of operators and rely on machine dependent optimization techniques for efficient implementation. Theoretically, parallelism in dataflow languages is limited by various dependencies introduced by the programmer in the programs. Most dataflow languages solve the problems associated with data dependencies by introducing the single-assignment rule; variables are not considered as place-holders for memory location, instead they represent values. Hence, variables can only be assigned once, which eliminates many of the dependencies. How ever intuitively appealing dataflow concepts may be, they have several shortcomings [GAJSK82]. It is argued that dataflow languages do not necessarily address the problem of increasing potential parallelism in applications but only simplify exploitation of parallelism. Removing the concept of variables as place-holder does not seem to provide a substantial improvement over traditional imperative languages [VEEN86]. More important, the strange programming style of dataflow (functional) languages acts as an impediment to programmers familiar with imperative languages. Explicit parallelism does not attempt to shield the programmer from parallelism. Instead it allows the programmer to annotate code that can be executed in parallel. Unfortunately, explicit parallelism is often based on a non-deterministic process model, even though most parallel programs are deterministic in nature. A program design for the process model divides its task into several parallel subtasks, which are executed on different processes. Although this approach is very flexible in many ways, it is also error-prone. The programmer is usually responsible for process creation and the allocation of tasks as well as synchronization and communication between the tasks. Even the more elaborate synchronization primitives are not immune to deadlock and since the processes may be non-deterministically scheduled, program testing may be complicated by the inability to create and recreate certain conditions for which the program fails. Many of the problems in parallel programming can be attributed to the extra effort the programmer has to spend on specifying implementation details. In addition, most parallel programs have a structure that resembles a specific parallel architecture, either based on a shared data model or alternatively on a message passing model. Ideally, however, we would like the programming tools to be flexible enough to effectively model the programming problem. In this report, we describe some features of a prototype parallel programming language, which provides a different flavour of parallel programming compared to most languages currently available. We believe a programmer should be able to control parallelism (i.e. dependencies), but unlike dataflow languages we concentrate on reducing dependencies on the procedural level and leave operator parallelism, if necessary, to the compiler. Like dataflow languages, a programmer does not need to supply details on implementation of the task system on a specific parallel architecture. Instead, we expect machine dependent optimization techniques to take care of efficient execution on both sequential and parallel architectures. Parallel Modula-2 or PM2 is our first language that investigates efficient object-based abstraction to support independent parallel procedure calls within the body of a loop. PM2 has been developed for the Melbourne University Optoelectronic Multicomputer Project [RUIGH88], which will rely on a static scheduling of parallel task systems on optically coupled Processing Elements to achieve maximal exploitation of parallelism. in [SIGPLAN] SIGPLAN Notices 25(09) September 1990 view details |