Programs written in concurrent object-oriented languages, espe-cially ones that employ thread-safe reusable class libraries, can execute synchronization operations (lock, notify, etc.) at an amaz-ing rate. Unless implemented with utmost care, synchronization can become a performance bottleneck. Furthermore, in languages where every object may have its own monitor, per-object space overhead must be minimized. To address these concerns, we have developed a meta-lock to mediate access to synchronization data. The meta-lock is fast (lock + unlock executes in 11 SPARCTM architecture instructions), compact (uses only two bits of space), robust under contention (no busy-waiting), and flexible (supports a variety of higher-level synchronization operations). We have vali-dated the meta-lock with an implementation of the synchronization operations in a high-performance product-quality JavaTM virtual machine and report performance data for several large programs.

We present a pragmatic methodology for designing nonblocking real-time systems. Our methodology uses a combination of lock-free and wait-free synchronization techniques and clearly states which technique should be applied in which situation.

ThreadMentor is a multiplatform pedagogical tool designed to ease the difficulty in teaching and learning multithreaded programming. It consists of a C++ class library and a visualization system. The class library supports many thread management functions and synchronization primitives in an object-oriented way, and the visualization system is activated automatically by a user program and shows the inner working of every thread and every synchronization primitive on-the-fly. Events can also be saved for playback. In this way, students will be able to visualize the dynamic behavior of a threaded program and the interaction among threads and synchronization primitives.

Abstract. The research concerning Java’s semantics and proof theory has mainly focussed on various aspects of sequential sub-languages. Java, however, integrates features of a class-based object-oriented language with the notion of multi-threading, where multiple threads can concurrently execute and exchange information via shared instance variables. Furthermore, each object can act as a monitor to assure mutual exclusion or to coordinate between threads. In this paper we present a sound and relatively complete assertional proof system for Java’s monitor concept, which generates verification conditions for a concurrent sublanguage JavaMT of Java. This work extends previous results by incorporating Java’s monitor methods.

The readers-writers problem is a classical one in the area of operating system and database. Although the problem has simple constraints, it has a feature that various scheduling policies can be applied to it. In this paper, we consider non-preemptive scheduling policies for solving the problem. In order to analyze detailed features of those policies, we dene scheduling points and items of the readers-writers problem and present their semaphore-based solutions with a common style. 1 Introduction The readers-writers problem which is rst formulated in [5] is a well-known, classical one in theory and practice of operating system and database. In the recent, the problem can be met easily in the multithreaded programming used for developing concurrent programs accessing a shared data [12, 14, 15]. In the readers-writers problem, the shared data must be always written by only one writer at any time. To do so, readers and writers, and writers and writers must access the data in fashion of ...

Abstract. Besides the features of a class-based object-oriented language, Java integrates concurrency via its thread classes. The concurrency model includes shared-variable concurrency via instance variables, coordination via reentrant synchronization monitors, synchronous message passing, and dynamic thread creation. To reason about safety properties of multithreaded Java programs, we introduce an assertional proof method for a multithreaded sublanguage of Java, covering the mentioned concurrency issues as well as the objectbased core of Java. The verification method is formulated in terms of proof-outlines, where the assertions are layered into local ones specifying the behavior of a single instance, and global ones taking care of the connections between objects. From the annotated program, a translator tool generates a number of verification conditions which are handed over to the interactive theorem prover PVS. 1

The development and maintenance of most real-time systems has always been problematic. In most real-time and embedded systems, software development usually employs ad-hoc methods, utilizing assembly or machine specific languages. Research on various algorithmic means for providing real-time program behaviour has been in existence since the 70's. Over the past two decades, real-time scheduling algorithms have gained tremendous popularity and maturity. However, a convenient means of utilizing such algorithms has lagged behind, given in part to the lack of a popular and flexible real-time programming language. Though various real-time programming languages exist, such languages usually offer little with regard to flexibility in controlling the underlying real-time scheduling algorithm. This thesis discusses the extension and transformation of a general purpose programming language into a flexible programming language suitable for real-time program development. iv Acknowledgements I wou...

Thread Optimizations in Concurrent Object Oriented Languages by Jing Wang With the current growth of the networks, distributed systems are becoming more and more popular. It is desirable to integrate heterogeneous machines into a coherent distributed system and to share resources among them. Scalable network computing also requires reliability, portability, and suitable programming abstractions. The Kan system was developed to meet these requirements. It supports fine-grained concurrency for the programmers, but hides the object distribution and concurrency control. This thesis introduces the concepts and implementations of asynchronous methods, nested atomic actions, guards, and some related concurrency issues. Concurrency involves extra time and space overheads of creating and scheduling threads. We want to achieve efficient multi-threaded without sacrificing good sequential performance. Some cost-effective implementations, thread inlining and an adaptive thread pool, are applied in ...

ions are too low level. Many PPSs are designed around specific mechanisms, instead of around problem-solving techniques. The programmer is responsible for correctness and performance tuning. The need for higher levels of abstraction is well known, but low-level PPSs continue to dominate the literature. One important exception is the work on data-parallel languages, such as High Performance Fortran (HPF) [KLS+94]. However, HPF only supports one paradigm for parallel programming, so it will not be examined in this survey of more general-purpose systems. 2. Interfaces are too low level. Sometimes, the abstractions are fairly high level (e.g., shared data on multicomputers), but the interface to the abstraction is too low level (e.g., load-store operations). With a low-level interface, it is more difficult for the PPS to transparently change the abstraction's implementation to use more efficient mechanisms and policies. Some researchers have argued for high-level interfaces [LKB+92], but t...