Diego Novillo

Concurrent SSA form in the presence of mutual exclusion

Most current compiler analysis techniques are unable to cope with the semantics introduced by explicit parallel and synchronization constructs in parallel programs. In this paper we propose new analysis and optimization techniques for compiling explicitly parallel programs that use mutual exclusion synchronization. We introduce the CSSAME form, an extension of the Concurrent Static Single Assignment (CSSA) form that incorporates mutual exclusion into a data flow framework for explicitly parallel programs. We show how this analysis can improve the effectiveness of constant propagation in a parallel program. We also modify a dead-code elimination algorithm to work on explicitly parallel programs. Finally, we introduce lock independent code motion, a new optimization technique that attempts to minimize the size of critical sections in the program.

Choosing among alternative futures

Non-determinism is a serious impediment to testing and debugging concurrent programs. Such programs do not execute the same way each time they are run, which can hide the presence of errors. Existing techniques use a variety of mechanisms that attempt to increase the probability of uncovering error conditions by altering the execution sequence of a concurrent program, but do not test for specific errors. This paper presents some preliminary work in deterministically executing a multithreaded program using a combination of an intermediate compiler form that identifies the set of writes of a shared variable by other threads are visible at a given read of that variable and aspect-oriented programming to control program execution. Specifically, the aspects allow a read of a shared variable to return any of the reaching definitions, where the desired definition can be selected before the program is run. As a result, we can deterministically run test cases. This work is preliminary and many issues have yet to be resolved, but we believe this idea shows some promise.

Optimizing Mutual Exclusion Synchronization in Explicitly Parallel Programs

We present two new compiler optimizations for explicitly parallel programs based on the CSSAME form: Lock-Independent Code Motion (LICM) and Mutex Body Localization (MBL). We have implemented these optimizations on top of the SUIF framework and present performance results for selected SPLASH applications.

Enterprise User's Manual Version 2.4

This document is a users manual for version 2.2 of the Enterprise parallel programming system. Enterprise is an interactive graphical programming environment for designing, coding, debugging, testing and executing programs in a distributed hardware environment. Enterprise code looks like familiar sequential code because the parallelism is expressed graphically and independently of the code. The system automatically inserts the code necessary to correctly handle communication and synchronization, allowing the rapid construction of distributed programs.

Identifying and validating irregular mutual exclusion synchronization in explicitly parallel programs

Existing work on mutual exclusion synchronization is based on a structural definition of mutex bodies. Although correct, this structural notion fails to identify many important locking patterns present in some programs. In this paper we present a novel analysis technique for identifying mutual exclusion synchronization patterns in explicitly parallel programs. We use this analysis in a new technique, called lock-picking, which detects and eliminates redundant mutex operations. We also show that this new mutex analysis technique can be used as a validation tool in a compiler. Using this analysis, a compiler can detect irregularities like lock tripping, deadlock patterns, incomplete mutex bodies, dangling lock and unlock operations and partially protected code.