Computer Science

Concurrency-related errors such as data races are frustratingly difficult to track down and eliminate in large object-oriented programs. Traditional approaches to preventing data races rely on protecting instruction sequences with synchronization operations. Such control-centric approaches are inherently brittle as the burden is on the programmer to ensure that all concurrently accessed memory locations are consistently protected. Data-centric synchronization is an alternative approach which offloads some of the work on the language implementation. Data-centric synchronization groups fields of objects into atomic sets to indicate that these fields always must be updated atomically. Each atomic set has associated units of work, code fragments that preserve the consistency of that atomic set. Synchronization operations are added automatically by the compiler. We present an extension to the Java programming language that integrates annotations for data-centric concurrency control. The resulting language, called AJ, relies on a type system that enables separate compilation and supports atomic sets that span multiple objects and that also supports full encapsulation for more efficient code generation. We evaluate our proposal by refactoring classes from standard libraries as well as a number of multi-threaded benchmarks to use atomic sets. Our results suggest that data-centric synchronization is easy to use, and enjoys low annotation overhead, while successfully preventing data races. Moreover, experiments on the SPECjbb benchmark suggest that acceptable performance can be achieved with a modest amount of tuning.

Previously, we developed a data-centric approach to concurrency control in which programmers specify synchronization constraints declaratively, by grouping shared locations into atomic sets. We implemented our ideas in a Java extension called AJ, using Java locks to implement synchronization. We proved that atomicity violations are prevented by construction, and demonstrated that realistic Java programs can be refactored into AJ without significant loss of performance.

Data-centric synchronization groups fields of objects into atomic sets to indicate they must be updated atomically. Each atomic set has associated units of work, code fragments that preserve the consistency of that atomic set. We present a type system for data-centric synchronization that enables separate compilation and supports atomic sets that span multiple objects, thus allowing recursive data structures to be updated atomically. The type system supports full encapsulation for more efficient code generation. We evaluate our proposal using AJ, which extends the Java programming language with data-centric synchronization. We report on the implementation of a compiler and on refactoring classes from standard libraries and a multi-threaded benchmark to use atomic sets. Our results suggest that data-centric synchronization enjoys low annotation overhead while preventing high-level data races.

Increasing levels of hardware parallelism are one of the main challenges for programmers and implementers of managed runtimes. Any concurrency or scalability improvements must be evaluated experimentally. However, application benchmarks available today may not reflect the highly concurrent applications we anticipate in the future. They may also behave in ways that VM developers do not expect. We provide a set of platform independent concurrency-related metrics and an in-depth observational study of current state of the art benchmarks, discovering how concurrent they really are, how they scale the work and how they synchronise and communicate via shared memory.

The need to express important non. Javal behaviors confronts the Ovm virtual machine framework no less than any other VM-in-Java project such as JikesRVM [1]. 2 Any such project needs mechanisms for the purpose, but different choices in the VM design affect the shape those mechanisms can take. In exploring how a component that makes nontrivial use of such mechanisms-the JMTk memory man-agement toolkit-can be made to interoperate with Dvm and JikesRVM, some Dvm mechanisms have been both ...

The SEAL calculus is a calculus of mobile computations designed for programming secure distributed applications over large scale open networks. The calculus is a distributed variant of the -calculus that incorporates agent mobility as well as strong protection mechanisms.

This paper scratches the surface of the problem of classifying the attacks that a mobile computation can be subjected to in an open network. The discussion is based on a simplified version of the Seal calculus. We show the impact of these attacks on the semantics of the calculus and on the notion of observational equivalence.

In recent years, various approaches to real-time execution of Java have proven their worth in numerous commercial and defense applications. The Real-time Specification for Java has extended the Java platform with a range of features needed for real-time computing. As the use of real-time Java has become more widespread, the demand for Java in real-time applications with safety requirements has led to an effort to define a new standard-JSR-302 Safety-Critical Java (SCJ). The goal of this standard is to facilitate the creation of safety-critical Java applications capable of certification under standards such as DO 178B level A or IEC61508 for SIL 4. JSR-302 is nearing completion and will soon be released for public review. This paper introduces some of the primary goals, challenges, and proposed solutions for safety-critical Java and its relationship with the Real-time Specification for Java.

The Real-time Specification for Java (RTSJ) has been designed to cover a large spectrum of real-time applications, to achieve this goal the specification must cater to different real-time programming styles. This generality is essential for acceptance of Java by the industry but it also means that there are many error modes that application developers must deal with. The memory subsystem of the RTSJ is one particular area where the RTSJ's generality creates complexity. This complexity is a problem in high integrity systems as it can be the source of errors, and runtime overheads.

High-level language virtual machines, e. g., for the Java programming language, offer a unique and challenging domain for aspects. This position paper motivates the need for an aspect-oriented language designed precisely for this domain. We start by overviewing examples of some of the crosscutting concerns we have refactored as aspects in VMs, and then demonstrate how mainstream aspectoriented programming languages need to be augmented in order to elegantly implement these and similar concerns. We believe current join point and advice models are not expressive enough for this domain. Predominantly this is due to the fact that the concept of a point in the execution of the VM requires the ability to explicitly specify subtle issues regarding system state and services. Finally, the paper outlines, based on a design view on virtual machines, the shape of a possible domain-specific aspect language for the implementation of such systems.