High-level Concurrent Language Research Articles

Coordination specification in distributed optimal design of multilevel systems using the ? language

Coordination plays a key role in solving de- composed optimal design problems. Several coordination strategies have been proposed in the multidisciplinary op- timization (MDO) literature. They are usually presented as a sequence of statements. However, a precise descrip- tion of the concurrency in the coordination is needed for large multilevel or non-hierarchic coordination archi- tectures. This article proposes the use of communicat- ing sequential processes (CSP) concepts from concur- rency theory for specifying and implementing coordina- tion strategies in distributed multilevel optimization rig- orously. CSP enables the description of the coordination as a number of parallel processes that operate indepen- dently and communicate synchronously. For this pur- pose, we introduce elements of the language χ ,aC SP- based language that contains advanced data modeling constructs. The associated software toolkit allows execu- tion of the specified coordination. Coordination specifi- cation using χ is demonstrated for analytical target cas- cading (ATC), a methodology for design optimization of hierarchically decomposed multilevel systems. It is shown that the ATC coordination can be compactly specified for various coordination schemes. This illustrates the ad- vantage of using a high-level concurrent language, such as χ, for specifying the coordination of distributed opti- mal design problems. Moreover, the χ software toolkit is

Automatic generation of self-scheduling programs

Techniques are described for the automatic generation of self-scheduling parallel programs. Both scheduling algorithms and the concurrent components of applications are expressed in a high-level concurrent language. Partitioning and data dependency information are expressed by simple control statements, which may be generated either automatically or manually. A self-scheduling compiler, implemented as a source-to-source transformation, takes application code, control statements, and scheduling routines and generates a new program that can schedule its own execution on a parallel computer. The approach has several advantages compared to previous proposals. It generates programs that are portable over a wide range of parallel computers. There is no need to embed special control structures in application programs. The use of a high-level language to express applications and scheduling algorithms facilitates the development, modification, and reuse of parallel programs.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Interfacing user processes an kernel in high level language

We present a method to simplify the implementation of a kernel supporting a high level concurrent language on a bare multiprocessor system.User and system level languages (with as much common syntax as possible) are defined. The system language consists of those constructs which do not require concurrency support, plus other facilities which make it well suited to write the kernel supporting the user language. Such constructs must provide the equivalent of a supervisor call interface within a high level language.All machine dependencies for both the system and user languages have been encapsulated in the code generation phase of the compilation process. Our method reduces the retargeting problem of a kernel to the orientability problem of the code generator.Finally our experiences in using such methodology are discussed.

A methodology for verifying request processing protocols

In this paper, we view computer networks as distributed systems that provide their users with a set of services, in a way which hides the distinction between those services which are local and those which are remote. We conceive of a given target network configuration as a network of communicating virtual machines and its behavior is modelled by a system of communicating sequential processes. Network protocols are described by a high level concurrent language (CSP) and a methodology is developed which permits the verification of partial and total correctness assertions about the system in a simple and natural way. Global invariants are used to establish invariant properties of the whole system and histories to record the sequence of communication exchanges between every matching pair of processes. Eventuality properties are expressed using linear temporal logic.

Some experiences of implementing the ada concurrency facilities on a distributed multiprocessor computer system

The paper first identifies the concurrency requirements for a high-level concurrent programming language, and then discusses how the concurrency primitives proposed for the programming language Ada meet these requirements. This is followed by a description of an actual implementation of the Ada tasking constructs on a distributed multiprocessor computer system comprising a number of multiprocessor-shared memory stations linked by a serial communications network. A brief description of the system and the overheads involved when implementing the rendezvous mechanism on this architecture is presented, and also the implications of processing interrupts by mapping them into external entry calls to high-level service tasks are discussed