We propose and evaluate a novel approach for automatic parallelization. The approach uses traces as units of parallel work. We discuss the benefits and challenges of the use of traces and propose an execution model for automatic parallelization based on traces. We implement a system that demonstrates the benefits and addresses the challenges of using traces for data-parallel applications in an offline feedback directed system. Finally, we evaluate our system by using it to automatically parallelize three sequential programs that exhibit data-level parallelism from the Java Grande benchmark suite. The resulting performance compares favorably to the performance achieved by hand parallelized versions of these programs. Thus, we demonstrate the viability of trace-based parallelization. 1.

Speculative multithreading (SpMT), or thread level speculation (TLS), is a dynamic parallelisation technique that uses out-of-order execution and memory buffering to achieve speedup. The complexity of implementing software SpMT results in long development lead times, and the lack of reuse between different software SpMT systems makes comparisons difficult. In order to address these problems we have created libspmt, a new language independent library for speculative multithreading. It provides a virtualization of speculative execution components that are unavailable in commercial multiprocessors, and enables method level speculation when fully integrated. We have isolated a clean and minimal library interface, and the corresponding implementation is highly modular. It can accommodate hosts that implement garbage collection, exceptions, and non-speculative multithreading. We created libspmt by refactoring a previous implementation of software SpMT for Java, and by aiming for modularity have exposed several new opportunities for optimization. 1

Many applications take advantage of parallelism to increase performance. Servers are a particularly common case as they must multiplex resources across many simultaneous users. Unfortunately, writing concurrent applications is difficult and prone to subtle and non-deterministic bugs that are difficult to reproduce. We advocate an approach to developing concurrent programs that is safe by default. Conservative static analysis determines when two code segments may safely run in parallel, and a runtime scheduler respects these constraints. We have built an analyzer for event-driven servers that discovers data sharing to find safe parallelism among event handlers. As a prototype, the analysis currently considers only global data, assuming that request-specific data structures passed to event handlers are completely independent. We have also begun work on a runtime system that schedules event handler execution within the constraints determined by the analyzer. For performance reasons, the scheduler makes additional conservative assumptions about contention. We have analyzed

The exploitation of parallelism among traces, i.e. hot paths of execution in programs, is a novel approach to the automatic parallelization of Java programs and it has many advantages. However, to date, the extent to which parallelism exists among traces in programs has not been made clear. The goal of this study is to measure the amount of tracelevel parallelism in several Java programs. We extend the Jupiter Java Virtual Machine with a simulator that models an abstract parallel system. We use this simulator to measure trace-level parallelism. We further use it to examine the effects of the number of processors, trace window size, and communication type and cost on performance. Our results indicate that enough trace-level parallelism exists for a modest number of processors. Thus, we conclude that trace-based parallelization is a potentially viable approach to improve the performance of Java programs.

Atomicity is an important property for concurrent software, as it provides a stronger guarantee against errors caused by unanticipated thread interactions than race-freedom does. However, concurrency control in general is tricky to get right because current techniques are too low-level and error-prone. Consequently, a new software abstraction is gaining popularity to take care of concurrency control and the enforcing of atomicity properties, called atomic sections. We propose an implementation of atomic sections using lock inference, a technique that infers the locks required for atomicity and inserts them transparently into the user’s program. The main advantages of our approach are (1) we infer path expressions for objects accessed inside the atomic section that resolve at run-time to the actual objects being accessed, (2) we use multi-granularity locking for when a finite number of fine grained locks cannot be inferred and per-object locks otherwise and (3) we ensure freedom from deadlock without requiring the need to coarsen the locking granularity at compile-time. Finally, we evaluate our approach by implementing a portion of the STMBench7 benchmark in a prototype object-oriented language called Single-step. We show that on some operations, our implementation can perform better than coarse locking. 2 I dedicate this to Lord Swaminarayan and my Guru HDH Pramukh Swami Maharaj.

The use of multi-core, multi-processor machines is opening new opportunities for software speculation, where program code is speculatively executed to improve performance at the additional cost of monitoring and error recovery. In this paper we describe a new system that use software speculation to support unsafely optimized code. We open a fast, unsafe track of execution but run the correct code on other processors to ensure correctness. We have developed an analytical model to measure the effect of major parameters including the speed of the fast track, its success rate, and its overheads. We have implemented a prototype and verified the correctness and performance using a synthetic benchmark on a 4-CPU machine. 1

A large class of legacy software systems, developed and maintained over many years, can also be termed sequential software systems in that independent parts of the system requires exclusive access to shared data during its entire execution. This requirement originates from design decisions on non-preemptive execution, and when the underlying architecture is a single-processor one, this is sufficient to protect the shared data. The problem arises when this architecture is to be replaced by a multi-processor ditto; since different tasks (still executed in a non-preemptive fashion, but on different processors) now may access, and update, the same data concurrently, non-preemptive execution does not protect the shared data any longer. To the above problem, we propose a solution based on a program analysis that can decide when parallel execution of the current software is safe in the sense that the parallel execution does not result in data interference. As a formal basis for such an analysis, the formal semantics of the language in question has to be considered. This thesis presents an operational semantics for the language PLEX, used to program the AXE telephone exchange system, in which the above mentioned properties are found: independent pieces of software, executed in a non-preemptive fashion, together with unprotected, shared data. 1 1

The zJava project aims to develop automatic parallelization technology for programs that use pointer-based dynamic data structures, written in Java. The system exploits parallelism among methods by creating an asynchronous thread of execution for each method invocation in a program. At compile-time, methods are analyzed to determine the data they access, parameterized by their context. A description of these data accesses is transmitted to a run-time system during program execution. The run-time system utilizes this description to determine when an invoked method may execute as an independent thread. The goal of this paper is to describe this run-time component of the zJava system and to report initial experimental results. In particular, the paper describes how the results of compile-time analysis are used at run-time to detect and enforce dependences among threads. Experimental results on a 4-processor Sun multiprocessor indicate that linear speedup may be obtained on sample applications and hence, validate our approach.

We describe and evaluate a novel approach for the automatic parallelization of programs that use pointer-based dynamic data structures, written in Java. The approach exploits parallelism among methods by creating an asynchronous thread of execution for each method invocation in a program. At compile time, methods are analyzed to determine the data they access, parameterized by their context. A description of these data accesses is transmitted to a run-time system during program execution. The runtime system utilizes this description to determine when a thread may execute, and to enforce dependences among threads. This run-time system is the main focus of this paper. More specifically, the paper details the representation of data accesses in a method and the framework used by the run-time system to detect and enforce dependences among threads. Experimental evaluation of an implementation of the run-time system on a four-processor Sun multiprocessor indicates that close to ideal speedup can be obtained for a number of benchmarks. This validates our approach.

The new era of multi-core processing challenges software designers to efficiently exploit the parallelism that is now massively available. Programmers have to exchange the conventional sequential programming paradigm for parallel programming: single-threaded designs must be decomposed into dependent, interacting tasks. The Java programming language has built-in thread support and is therefore suitable for the development of parallel software, but programming multi-threaded applications is a tedious task. Therefore we are working on a framework and tool support to alleviate the burden of threads, synchronisation and locking, based on process networks. This paper describes our initial ideas for this new programming model. 1