Threads are the vehicle,for concurrency in many approaches to parallel programming. Threads separate the notion of a sequential execution stream from the other aspects of traditional UNIX-like processes, such as address spaces and I/O descriptors. The objective of this separation is to make the expression and control of parallelism sufficiently cheap that the programmer or compiler can exploit even fine-grained parallelism with acceptable overhead. Threads can be supported either by the operating system kernel or by user-level library code in the application address space, but neither approach has been fully satisfactory. This paper addresses this dilemma. First, we argue that the performance of kernel threads is inherently worse than that of user-level threads, rather than this being an artifact of existing implementations; we thus argue that managing par- allelism at the user level is essential to high-performance parallel computing. Next, we argue that the lack of system integration exhibited by user-level threads is a consequence of the lack of kernel support for user-level threads provided by contemporary multiprocessor operating systems; we thus argue that kernel threads or processes, as currently conceived, are the wrong abstraction on which to support user- level management of parallelism. Finally, we describe the design, implementation, and performance of a new kernel interface and user-level thread package that together provide the same functionality as kernel threads without compromis- ing the performance and flexibility advantages of user-level management of parallelism.

In this paper we describe restartable atomic sequences, an optimistic mechanism for implementing simple atomic operations (such as Test-And-Set) on a uniprocessor. A thread that is suspended within a restartable atomic sequence is resumed by the operating system at the beginning of the sequence, rather than at the point of suspension. This guarantees that the thread eventually executes the sequence atomically. A restartable atomic sequence has signi cantly less overhead than other software-based synchronization mechanisms, such askernel emulation or software reservation. Consequently, it is an attractive alternative for use on uniprocessors that do not support atomic operations. Even on processors that do support atomic operations in hardware, restartable atomic sequences can have lower overhead. We describe di erent implementations of restartable atomic sequences for the Mach 3.0 and Taos operating systems. These systems ' thread management packages

We describe a memory management toolkit for language implementors. It offers efficient and flexible generation scavenging garbage collection. In addition to providing a core of languageindependent algorithms and data structures, the toolkit includes auxiliary components that ease implementation of garbage collection for programming languages. We have detailed designs for Smalltalk and Modula-3 and are confident the toolkit can be used with a wide variety of languages. The toolkit approach is itself novel, and our design includes a number of additional innovations in flexibility, efficiency, accuracy, and cooperation between the compiler and the collector. This project is supported by National Science Foundation Grant CCR-8658074, and by Digital Equipment Corporation, GTE Laboratories, and Apple Computer. 1 Introduction As part of an ongoing effort to implement Persistent Smalltalk and Persistent Modula-3, we have designed a high performance garbage collector toolkit that can be us...

Following our own experience developing a concurrent object-oriented language as well of that of other researchers, we have identb))1 several key problems intT design of a concurrency model compat1}+ wit t he mechanisms ofobject}+4gTT1t programming. We propose an approacht language design in which anexecut1}+ notcut describingte behaviour ofcommunicatTT agent isext+T5+ bysynt4g81 pat4g8 tt encapsulat languageconste1T)+ Weindicat how various language models can beaccommodat5T and how mechanisms such as inherit}+5 can be modeled. Finally, weint6+TT1 a newnotb( oft ypest hat charact(1}T6 concurrent object in t1+6 oft15+ ext5g41}T visible behaviour. 1.

The object-oriented paradigm has gained popularity in various guises not only in programming languages, but in user interfaces, operating systems, databases, and other areas. We argue that the fundamental object-oriented concept is encapsulation, and that all object-oriented mechanisms and approaches exploit this idea to various ends. We introduce the most important of these mechanisms as they are manifested in existing object-oriented systems, and we discuss their relevance in the context of modern application development.

We describe the design, implementation and use of a mechanism for handling asynchronous signals, such as user interrupts, in the New Jersey implementation of Standard ML. Providing this kind of mechanism is a necessary requirement for the development of real-world application programs. Our mechanism uses first-class continuations to represent the execution state at the time at which a signal occurs. It has been used to support pre-emptive scheduling in concurrency packages and for forcing break-points in debuggers, as well as for handling user interrupts in the SML/NJ interactive environment. 1 Introduction Programs normally receive communication from the outside world via input operations. This method of communication is inherently synchronous: there is no way for the outside world to force the program to accept communication. But sometimes it is necessary to communicate asynchronously; for example, if the user wants to interrupt execution, or if the operating system needs to inform a...

The integration of concurrent and object-oriented programming, although promising, presents problems that have not yet been fully explored. In this paper we attempt to identify issues in the design of concurrent object-oriented languages that must be addressed to achieve a satisfactory integration of concurrency in the object-oriented framework. We consider the approaches followed by object-oriented languages for supporting concurrency and identify six categories of concurrent object-oriented languages. Then, we review several concurrent object-oriented languages and examine the interaction of their concurrency features with their object-oriented features and with object-oriented software construction. 1 Introduction Object-oriented programming and object-oriented programming languages (OOPLs) are becoming increasingly popular for the construction of computer software. OOPLs integrate a host of techniques that have proven useful for the development and maintenance of software and that...

: Many garbage-collected systems, including most that involve a stop-the-world phase, restrict GC to socalled GC points. In single-threaded environments, GC points carry no overhead: when a GC must be done, the single thread is already at a GC point. In multi-threaded environments, however, only the thread that triggers the GC by failing an allocation will be at a GC point. Other threads must be rolled forward to their next GC point before the GC can take place. We compare, in the context of a high-performance Java^TM virtual machine, two approaches to advancing threads to a GC point, polling and code patching, while keeping all other factors constant. Code patching outperforms polling by an average of 4.7% and sometimes by as much as 11.2%, while costing only slightly more compiled code space. Put differently, since most programs spend less than 1/5 of the time in GC, a 4.7% bottom-line speedup amounts to more than a 20% reduction in the GC-related costs. Patching is, however, more di...

Abstract not found

A framework for the semantic description of concurrent object-oriented languages based on CCS is outlined. We discuss how the essential object-oriented features, such as encapsulation, object identity, classes, inheritance and concurrency are captured. Then, the proposed framework is used for defining the semantics of significantly different versions of a toy language which supports the above features. The ease with which the different versions of this language are accommodated provides some evidence for the applicability of the framework for a wide range of languages, as well as its usefulness for comparing different language designs and examining the interaction of a rich set of object-oriented features. 1. Introduction A great variety of approaches has been taken for the design of concurrent object-based languages concerning the way that concurrency is taken into account within the object model and the way that the concurrency features are combined with other object-based features ...