Doug Lea

A Java fork/join framework

This paper describes the design, implementation, and performance of a Java framework for supporting a style of parallel programming in which problems are solved by (recursively) splitting them into subtasks that are solved in parallel, waiting for them to complete, and then composing results. The general design is a variant of the work-stealing framework devised for Cilk. The main implementation techniques surround efficient construction and management of tasks queues and worker threads. The measured performance shows good parallel speedups for most programs, but also suggests possible improvements.

The Geneva convention on the treatment of object aliasing

Aliasing has been a problem in both formal verification and practical programming for a number of years. To the formalist, it can be annoyingly difficult to prove the simple Hoare formula {x = true} y := false {x = true}. If x and y refer to the same boolean variable, i.e., x and y are aliased, then the formula will not be valid, and proving that aliasing cannot occur is not always straightforward. To the practicing programmer, aliases can result in mysterious bugs as variables change their values seemingly on their own. A classic example is the matrix multiply routine mult(left, right, result) which puts the product of its first two parameters into the third. This works perfectly well until the day some unsuspecting programmer writes the very reasonable statement mult(a, b, a). If the implementor of the routine did not consider the possibility that an argument may be aliased with the result, disaster is inevitable.

The java.util.concurrent synchronizer framework

Most synchronizers (locks, barriers, etc.) in the J2SE 5.0 java.util.concurrent package are constructed using a small framework based on class AbstractQueuedSynchronizer. This framework provides common mechanics for atomically managing synchronization state, blocking and unblocking threads, and queuing. The paper describes the rationale, design, implementation, usage, and performance of this framework.

Interface-Based Protocol Specification of Open Systems using PSL

PSL is a framework for describing dynamic and architectural properties of open systems of components. PSL extends established interface-based tactics for describing the functional properties of open systems to the realm of protocol description. PSL specifications consist of logical and temporal rules relating situations, each of which describes potential states with respect to the roles of components, role attributes, and the issuance and reception of events. A specialized form, PSL/IDL supports protocol description in CORBA systems.

Scalable synchronous queues

In a thread-safe concurrent queue, consumers typically wait for producers to make data available. In a synchronous queue, producers similarly wait for consumers to take the data. We present two new nonblocking, contention-free synchronous queues that achieve high performance through a form of dualism: The underlying data structure may hold both data and, symmetrically, requests. We present performance results on 16-processor SPARC and 4-processor Opteron machines. We compare our algorithms to commonly used alternatives from the literature and from the Java SE 5.0 class java.util.concurrent.SynchronousQueue both directly in synthetic microbenchmarks and indirectly as the core of Javas ThreadPoolExecutor mechanism. Our new algorithms consistently outperform the Java SE 5.0 SynchronousQueue by factors of three in unfair mode and 14 in fair mode; this translates to factors of two and ten for the ThreadPoolExecutor. Our synchronous queues have been adopted for inclusion in Java 6.

Design for Open Systems in Java

Open systems consist of unbounded collections of objects that may interact in support of any of a number of activities. The features and services provided by each object require various measures of policy control of infrastructure components in order to provide appropriate quality of service for supported activities. This paper surveys some common and emerging Java-based design patterns for establishing and controlling service and application components in open object-oriented architectures.

SIGPLAN programming language curriculum workshop: Discussion Summaries and recommendations

A college education has two goals. First, to produce intellectually mature, sophisticated leaders who can think deeply and productively in a range of fields and contexts. Second, to provide students with skills that they can apply successfully throughout a long career in their chosen profession or professions. Programming language concepts and ways of thinking can be a critically important part of the successful education of virtually any college student, regardless of discipline. For computer scientists these concepts and ways of thinking are indispensible.

Languages and performance engineering: method, instrumentation, and pedagogy

Programs encounter increasingly complex and fragile mappings to computing platforms, resulting in performance characteristics that are often mysterious to students, practitioners, and even researchers. We discuss some steps toward an experimental methodology that demands and provides a deep understanding of complete systems, the necessary instrumentation and tools to support such a methodology, and a curriculum that teaches the methodology and tools as a fundamental part of the discipline.

Scripting distributed agents

The TRUCE language and ACACIA distributed infrastructure extend common notions of scripting to the realm of distributed agents. This paper provides an overview of how TRUCE and ACACIA approach the issues of openness, concurrency, and decentralization encountered when trying to apply scripting to autonomous distributed components.

Aliasing in Object Oriented Systems

This chapter contains summaries of the presentations given at the Intercontinental Workshop on Aliasing in Object-Oriented Systems (IWAOOS’99) at the European Conference on Object-Oriented Programming (ECOOP’99) which was held in Lisbon, Portugal on June 15, 1999.