p4 is a portable library of C and Fortran subroutines for programming parallel computers. It is the current version of a system that has been in use since 1984. It includes features for explicit parallel programming of shared-memory machines, distributed-memory machines (including heterogeneous networks of workstations), and clusters, by which we mean sharedmemory multiprocessors communicating via message passing. We discuss here the design goals, history, and system architecture of p4 and describe briefly a diverse collection of applications that have demonstrated the utility of p4. 1 Introduction p4 is a library of routines designed to express a wide variety of parallel algorithms portably, efficiently and simply. The goal of portability requires it to use widely accepted models of computation rather than specific vendor implementations of those models. The goal of efficiency requires it to use models of computation relatively close to those provided by the machines themselves and t...

Abstract not found

. Any multiprocessing facility must include three features: elementary exclusion, data protection, and process saving. While elementary exclusion must rest on some hardware facility (e.g., a test-and-set instruction), the other two requirements are fulfilled by features already present in applicative languages. Data protection may be obtained through the use of procedures (closures or funargs), and process saving may be obtained through the use of the catch operator. The use of catch, in particular, allows an elegant treatment of process saving. We demonstrate these techniques by writing the kernel and some modules for a multiprocessing system. The kernel is very small. Many functions which one would normally expect to find inside the kernel are completely decentralized. We consider the implementation of other schedulers, interrupts, and the implications of these ideas for language design. 1. Introduction In the past few years, researchers have made progress in understanding the mecha...

CC++ is Compositional C++ , a parallel object-oriented notation that consists of C++ with six extensions. The goals of the CC++ project are to provide a theory, notation and tools for developing reliable scalable concurrent program libraries, and to provide a framework for unifying: 1. distributed reactive systems, batch-oriented numeric and symbolic applications, and user-interface systems, 2. declarative programs and object-oriented imperative programs, and 3. deterministic and nondeterministic programs. This paper is a brief description of the motivation for CC++ , the extensions to C++ , a few examples of CC++ programs with reasoning about their correctness, and an evaluation of CC++ in the context of other research on concurrent computation. A short description of C++ is provided.

The memory consistency model for a shared-memory multiprocessor specifies the behavior of memory with respect to read and write operations from multiple processors. As such, the memory model influences many aspects of system design, including the design of programming languages, compilers, and the underlying hardware. Relaxed models that impose fewer memory ordering constraints offer the potential for higher performance by allowing hardware and software to overlap and reorder memory operations. However, fewer ordering guarantees can compromise programmability and portability. Many of the previously proposed models either fail to provide reasonable programming semantics or are biased toward programming ease at the cost of sacrificing performance. Furthermore, the lack of consensus on an acceptable model hinders software portability across different systems. This dissertation focuses on providing a balanced solution that directly addresses the trade-off between programming ease and performance. To address programmability, we propose an alternative method for specifying memory behavior that presents a higher level abstraction to the programmer. We show that with only a few types of information supplied by the

Abstract: The author examines the synchronization features of Java and finds that they are insecure variants of his earliest ideas in parallel programming published in 1972-73. The claim that Java supports monitors is shown to be false. The author concludes that Java ignores the last twenty-five years of research in parallel programming languages. Zeywords: programming languages; parallel programming; monitors; security; Java; We must expect posterity to view with some asperity the marvels and the wonders we're passing on to it; but it should change its attitude to one of heartfelt gratitude when thinking of the blunders we didn't quite commit. 1. PLATFORM-INDEPENDENT PARALLEL PROGRAMMING Pier Hein (1966) Java has resurrected the well-known idea of platform-independent parallel program-ming. In this paper I examine the synchronization features of Java to discover their origin and determine if they live up to the standards set by the invention of monitors and Concurrent Pascal a quarter of a century ago. In the 1970s my students and I demonstrated that it is possible to write nontriv-ial parallel programs exclusively in a secure language that supports monitors. The milestones of this work were: • The idea of associating explicit queues with monitors [Brinch Hansen 1972]. • A class notation for monitors [Brinch Hansen 1973]. • A monitor language, Concurrent Pascal [Brinch Hansen 1975a]. • A portable compiler that generated platform-independent parallel code [Hart-mann 1975]. • A portable interpreter that ran platform-independent parallel code on a wide variety of computers [Brinch Hansen 1975b].

A language concept for concurrent processes without common variables is introduced. These processes communicate and synchronize by means of procedure calls and guarded regions. This concept is proposed for real-time applications controlled by microcomputer networks with distributed storage. The paper gives several examples of distributed processes and shows that they include

Embedded systems use specialized hardware devices to interact with their environment, and since they have to be dependable, it is attractive to use a modern, type-safe programming language like Java to develop programs for them. Standard Java, as a platform independent language, delegates access to devices, direct memory access, and interrupt handling to some underlying operating system or kernel, but in the embedded systems domain resources are scarce and a Java virtual machine (JVM) without an underlying middleware is an attractive architecture. The contribution of this paper is a proposal for Java packages with hardware objects and interrupt handlers that interface to such a JVM. We provide implementations of the proposal directly in hardware, as extensions of standard interpreters, and finally with an operating system middleware. The latter solution is mainly seen as a migration path allowing Java programs to coexist with legacy system components. An important aspect of the proposal is that it is compatible with the Real-Time Specification for Java (RTSJ).

Emerald is an object-based programming language and system designed and implemented in the Department of Computer Science at the University of Washington in the early and mid-1980s. The goal of Emerald was to simplify the construction of distributed applications. This goal was reflected at every level of the system: its object structure, the programming language design, the compiler implementation, and the run-time support. This paper describes the origins of the Emerald group, the forces that formed the language, the influences that Emerald has had on subsequent distributed systems and programming languages, and some of Emerald’s more interesting technical innovations.

A general machine independent language for parallel programming is strongly needed. In this dissertation a general object-oriented programming language, Ellie, for machine independent programming of distributed parallel computers is designed, partly implemented, and evaluated. Generality is provided by having first class objects used for abstracting classes, methods, control structures, types, and instance objects. Furthermore, a conformity based type system and new powerful synchronization and delegation approaches are investigated. Machine independence is supported by grain-size reduction (adaption to an actual distributed parallel computer) in compilation of fine-grained programs. This approach is discussed and partly evaluated by experiments using a transputer network implementation of Ellie. The main contributions of this dissertation concern first class objects with static typing, high level fine-grained parallelism, and grain-size adaption. Keywords Object-oriented languages, G...