Parallel Language Research Articles

Teixits grecs o allò femení en antitesi

In the world of Ancient Greece, fabric and weaving are inextrincably linked to the existence of women and take on the quality of symbolic reference. In the literature, the loom represents a kind of barrier between the Gynaeceum and the outside world, the fabric constituting a parallel language on the subject of femininity.

Instant replay debugging of concurrent logic programs

One problem with debugging (committed choice) concurrent logic programs is that their behaviour may be non-deterministic, in that successive executions of the same program may produce different results. We describe a scheme, based on the ‘Instant Replay’ scheme developed for more conventional parallel languages, that allows us to reproduce the execution behaviour of a concurrent logic program on subsequent executions, so that the execution may be examined for debugging purposes. The properties of concurrent logic programming languages allow us to simplify our scheme greatly. We have demonstrated our scheme with KLIC, and KL1 on the PIM multiprocessors, but it can also be applied to other committed choice concurrent logic programming languages.

Balinda suite of languages and implementations

The BaLinda suite of parallel languages, currently consisting of BaLinda Lisp, BaLinda Pascal, and BaLinda Fortran, aim at providing a pragmatic parallel programming model. They incorporate the Linda tuplespace and support both mandatory and speculative parallelism. They have been implemented on a network of transputers and SUN workstations. A number of examples of parallel programming applications in BaLinda languages are presented to show that the languages are worthwhile additions to the family of parallel languages. A distributed Linda tuplespace implementation and dynamic load balancing strategies for BaLinda languages are also presented, and their performances are evaluated, demonstrating an efficient, reliable, and portable way to realize BaLinda suite of languages on distributed parallel machines.

ON SYNCHRONIZATION LANGUAGES

New constructs for synchronization termed synchronization expressions (SEs) have been developed as high-level language constructs for parallel programming languages [8, 9]. Statements that are constrained by certain synchronization requirements are tagged, and synchronization requests are specified as expressions of statement tags. In this paper, we introduce a new family of languages named synchronization languages which we use to give a precise semantic description for SEs. Under this description, relations such as equivalence and inclusion between SEs can be easily understood and tested. In practice, it also provides us with a systematic way for the implementation as well as the simplification of SEs in parallel programming languages. We show that each synchronization language is closed under the following rewriting rules: (1) asbs → bsas, (2) atbt → btat, (3) asbt → btas, (4) atasbtbs → btbsatas and also h(atasbtbs) → h(btbsatas) for any morphism h that satisfies certain conditions which will be specified in the paper. We conjecture that closure under the above rewriting rules is a sufficient condition for a regular st-language to be a synchronization language. Several other properties of synchronization languages are also studied.

Blackboard-based extensions in Prolog

This paper presents the embedding of blackboard communication primitives in Prolog. Blackboard communication is a simple but powerful form of communication that is based upon the availability of a global data structure that can be accessed by any process in a controlled way. This results in a parallel language that exploits coarse-grained application parallelism and that is related to the Linda framework. This paper contains a description of the blackboard communication primitives at the language and at the implementation level, and it is illustrated with several programming examples.

Blackboard‐based extensions in Prolog

This paper presents the embedding of blackboard communication primitives in Prolog. Blackboard communication is a simple but powerful form of communication that is based upon the availability of a global data structure that can be accessed by any process in a controlled way. This results in a parallel language that exploits coarse-grained application parallelism and that is related to the Linda framework. This paper contains a description of the blackboard communication primitives at the language and at the implementation level, and it is illustrated with several programming examples.

Decomposition abstraction in parallel rule languages

Decomposition abstraction is the process of organizing and specifying decomposition strategies for the exploitation of parallelism available in an application. In this paper we develop and evaluate declarative primitives for rule-based programs that expand opportunities for parallel execution. These primitives make explicit, implicit relations among the data and similarly among the rules. The semantics of the primitives are presented in a general object-based framework such that they may be applied to most rule-based programming languages. We show how the additional information provided by the decomposition primitives can be incorporated into a semantic-based dependency analysis technique. The resulting analysis reveals parallelism at compile time that is very difficult, if not impossible, to discover by traditional syntactic analysis techniques. Simulation results demonstrate scalable and broadly available parallelism.

Visualization of RNA secondary structures using highly parallel computers.

Results of RNA secondary structure prediction algorithm are usually given as a set of hydrogen bonds between bases. However, we cannot know the precise structure of an RNA molecule by only knowing which bases form hydrogen bonds. One way to understand the structure of an RNA molecule is to visualize it using a planar graph so that we can easily know the geometric relations among the substructures such as stacking regions and loops. To do this, we consider bases to be particles on a plane and introduce a repulsive force and an attractive force among these particles and determine their positions according to these forces. A naive algorithm requires O(N2) time but we can reduce it to O(NlogN) with an approximation algorithm which is often used in the area of N-body simulation. Our program is written in parallel object-oriented language 'Schematic' which is recently developed. Efficiency of our implementation on a parallel computer and results of visualization of secondary structures are presented using cadang-cadang coconut viroid as an example.

Using the Cowichan problems to assess the usability of Orca

The Cowichan problems are a suite of six applications for assessing the usability of parallel programming systems: the Turing ring, Kece, active chart parsing, image thinning and skeletonization, polygon overlay, and a skyline matrix solver. The authors and their colleagues implemented the applications in Orca, a parallel language based on shared objects. This experiment taught the authors useful lessons about Orca's parallel programming model, parallel efficiency, sequential language constructs, and programming environment. It can also give the designers of other parallel programming systems an idea of what to expect when using the Cowichan problems.

An implementation framework for HPF distributed arrays on message-passing parallel computer systems

Data parallel languages, like High Performance Fortran (HPF), support the notion of distributed arrays. However, the implementation of such distributed array structures and their access on message passing computers is not straightforward. This holds especially for distributed arrays that are aligned to each other and given a block-cyclic distribution. In this paper, an implementation framework is presented for HPF distributed arrays on message passing computers. Methods are presented for efficient (in space and time) local index enumeration, local storage, and communication. Techniques for local set enumeration provide the basis for constructing local iteration sets and communication sets. It is shown that both local set enumeration and local storage schemes can be derived from the same equation. Local set enumeration and local storage schemes are shown to be orthogonal, i.e., they can be freely combined. Moreover, for linear access sequences generated by our enumeration methods, the local address calculations can be moved out of the enumeration loop, yielding efficient local memory address generation. The local set enumeration methods are implemented by using a relatively simple general transformation rule for absorbing ownership tests. This transformation rule can be repeatedly applied to absorb multiple ownership tests. Performance figures are presented for local iteration overhead, a simple communication pattern, and storage efficiency.

An effective data parallel self‐starting explicit methodology for computational structural dynamics on the connection machine CM‐5

AbstractThis paper discusses the implementation aspects and our experiences towards a data parallel explicit self‐starting finite element transient methodology with emphasis on the Connection Machine (CM‐5) for linear and non‐linear computational structural dynamic applications involving structured and unstructured grids. The parallel implementation criteria that influence the efficiency of an algorithm include the amount of communication, communication routing, and load balancing. To provide simplicity, high level of accuracy, and to retain the generality of the finite element implementation for both linear and non‐linear transient explicit problems on a data parallel computer which permit optimum amount of communications, we implemented the present self‐starting dynamic formulations (in comparison to the traditional approaches) based on nodal displacements, nodal velocities, and elemental stresses on the CM‐5. Data parallel language CMFortran is employed with virtual processor constructs and with:SERIAL and:PARALLEL layout directives for arrays. The communications via the present approach involve only one gather operation (extraction of element nodal displacements or velocities from global displacement vector) and one scatter operation (dispersion of element forces onto global force vector) for each time step. These gather and scatter operations are implemented using the Connection Machine Scientific Software Library communication primitives for both structured and unstructured finite element meshes. The implementation aspects of the present self‐starting formulations for linear and elastoplastic applications on serial and data parallel machines are discussed. Numerical test models for linear and non‐linear one‐dimensional applications and a two‐dimensional unstructured finite element mesh are then illustrated and their performance studies are discussed.

2DT-FP: A parallel functional programming language on two-dimensional data

We propose a new paradigm for programming multiprocessor systems, 2DT (two-dimensional transformations). 2DT programs are composed of local computations on linear data (columns) and global transformations on 2-dimensional combinations of columns (2D-arrays). Local computations can be expressed in a functional or imperative base language; a typed variant of Backus' FP is chosen for 2DT-FP. The level of abstraction of 2DT makes it suitable for programming a relevant set of algorithms, in general any algorithms, whose data can be easily mapped to 2-dimensional representations. A set of examples tries to prove this claim. An interleaving semantics for 2DT-FP is given, exposing the potential for parallel execution of 2DT-FP programs. The claim is proved that any sequential and thus any parallel execution will deliver the same result. The implementation realized on the Intel Hypercube is described.

DPL

T HE NEED FOR a powerful, easy to use, parallel language continues despite very significant advances in the area of parallel processing. Many parallel languages are simply old sequential languages with parallel constructs added. This research describes the Data Parallel Language (DPL), a parallel language built from its foundations on parallel concepts. DPL bases much of its expression on data parallelism found in APL2 and Fortran90. DPL uses a method based on Petri nets for controlling the execution of groups of statements. Therefore, it allows the user to express parallel algorithms in a natural, array-based method that is independent of the underlying parallel architecture.APL has been recognized as a naturally parallel language because of its ability to express algorithms on array arguments directly. This eliminates the need for a programmer to convert them into sequential loops. Fortran90 has recently adopted similar data parallel concepts into the Fortran language. DPL borrows from APL2 and Fortran90 to define an extensive data parallel function set. Functions in DPL are designed to take arrays as arguments and map the execution onto the underlying parallel machine.Petri nets provide a very elegant model for expressing concurrent and asynchronous operations. DPL uses the semantics of Petri nets to provide a general purpose control structure. DPL frees the programmer from having a fixed set of parallel control constructs, such as are provided in most parallel languages. Rather, it provides a method to express parallel execution based only on the input and output conditions of parts of the program.This work provides the complete syntax and semantics of DPL and then explores its use. The expressiveness of the language is demonstrated by showing how common parallel structures can be implemented. The ease of use is analyzed using a study of existing APL2 code to determine the amount of implicit parallelism in an array language. Some of the issues of compiling DPL are discussed and theoretical speedups are given. The advantages of DPL over other languages, especially APL2 and Fortran90, are outlined.

An array operation synthesis scheme to optimize Fortran 90 programs

An increasing number of programming languages, such as Fortran 90 and APL, are providing a rich set of intrinsic array functions and array expressions. These constructs which constitute an important part of data parallel languages provide excellent opportunities for compiler optimizations. In this paper, we present a new approach to combine consecutive data access patterns of array constructs into a composite access function to the source arrays. Our scheme is based on the composition of access functions, which is similar to a composition of mathematic functions. Our new scheme can handle not only data movements of arrays of different numbers of dimensions and segmented array operations but also masked array expressions and multiple sources array operations. As a result, our proposed scheme is the first synthesis scheme which can synthesize Fortran 90 RESHAPE, EOSHIFT, MERGE, and WHERE constructs together. Experimental results show speedups from 1.21 to 2.95 for code fragments from real applications on a Sequent multiprocessor machine by incorporating the proposed optimizations.

UC: A Set-Based Language for Data-Parallel Programming

UC is a data-parallel extension of C designed for scientific computations on synchronous and asynchronous parallel architectures. The primary constructs of the language include sets, reductions, and parallel and asynchronous composition. Its communication model is that of a globally addressable memory, with no syntactic distinction between local and remote data references, Unlike most existing data-parallel languages, UC programs may be synchronized at multiple levels of granularity, from a strict expression-level synchronization to a coarser statement or function-level synchronization. This paper describes the language and its implementation on the Connection Machine CM-2. Experimental measurements that compare the performance of the UC compiler with that of programs written in commercial parallel languages such as CM Fortran, C*, and *Lisp are also presented.

Parallel natural language processing on a semantic network array processor

This paper presents a parallel natural language processing system implemented on a marker-passing parallel AI computer, the Semantic Network Array Processor (SNAP). Our system uses a memory-based parsing approach in which parsing is viewed as a memory search process. Linguistic information is stored as phrasal patterns in a semantic network knowledge base distributed over the memory of the parallel computer. Parsing is performed by recognizing and linking phrasal patterns that reflect a sentence interpretation. This is achieved by propagating markers over the distributed network. We have developed a system capable of processing newswire articles from a particular domain. The paper presents the structure of the system, the memory-based parsing method used, and the performance results obtained. >

P3L: A structured high‐level parallel language, and its structured support

AbstractThe paper presents a parallel programming methodology that ensures easy programming, efficiency and portability of programs to different machines belonging to the class of the general‐purpose, distributed‐memory, MIMD architectures. The methodology is based on the definition of a new, high‐level, explicitly parallel language, called P3 L, and of a set of static tools that automatically adapt the program features for each target architecture.P3 L does not require programmers to specify process activations, the actual parallelism degree, scheduling, or interprocess communications, i.e. all those features that need to be adjusted to harness each specific target machine. Parallelism is, on the other hand, expressed in a structured and qualitative way, by hierarchical composition of a restricted set of language constructs, corresponding to those forms of parallelism that are frequently encountered in parallel applications, and that can be efficiently implemented.The efficient portability of P3 L applications is guaranteed by the compiler along with the novel structure of the support. The compiler automatically adapts the program features for each specific architecture, using the costs (in terms of performance) of the low‐level mechanisms exported by the architecture itself. In our methodology, these costs, along with other features of the architecture, are viewed through an abstract machine, whose interface is used by the compiler to produce the final object code.

Empirical evaluation of the CRAY-T3D

Most recent MPP systems employ a fast microprocessor surrounded by a shell of communication and synchronization logic. The CRAY-T3D provides an elaborate shell to support global-memory access, prefetch, atomic operations, barriers, and block transfers. We provide a detailed empirical performance characterization of these primitives using micro-benchmarks and evaluate their utility in compiling for a parallel language. We have found that the raw performance of the machine is quite impressive and the most effective forms of communication are prefetch and write. Other shell provisions, such as the bulk transfer engine and the external Annex register set, are cumbersome and of little use. By evaluating the system in the context of a language implementation, we shed light on important trade-offs and pitfalls in the machine architecture.

Processing in memory: the Terasys massively parallel PIM array

SRC researchers have designed and fabricated a processor-in-memory (PIM) chip, a standard 4-bit memory augmented with a single-bit ALU controlling each column of memory. In principle, PIM chips can replace the memory of any processor, including a supercomputer. To validate the notion of integrating SIMD computing into conventional processors on a more modest scale, we have built a half dozen Terasys workstations, which are Sun Microsystems Sparcstation-2 workstations in which 8 megabytes of address space consist of PIM memory holding 32K single-bit ALUs. We have designed and implemented a high-level parallel language, called data parallel bit C (dbC), for Terasys and demonstrated that dbC applications using the PIM memory as a SIMD array run at the speed of multiple Cray-YMP processors. Thus, we can deliver supercomputer performance for a small fraction of supercomputer cost. Since the successful creation of the Terasys research prototype, we have begun work on processing in memory in a supercomputer setting. In a collaborative research project, we are working with Cray Computer to incorporate a new Cray-designed implementation of the PIM chips into two octants of Cray-3 memory.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Rendezvous facilities in a distributed computer system

The distributed computer system described in this paper is a set of computer nodes interconnected in an interconnection network via packet-switching interfaces. The nodes communicate with each other by means of message-passing protocols. This paper presents the implementation of rendezvous facilities as high-level primitives provided by a parallel programming language to support interprocess communication and synchronization.