CAS-based lock-free algorithm for shared deques

Abstract. This paper presents the first lock-free algorithm for shared double-ended queues (deques) based on the single-address atomic primitives CAS (Compare-and-Swap) or LL/SC (Load-Linked and Store-Conditional). The algorithm can use single-word primitives, if the maximum deque size is static. To allow the deque’s size to be dynamic, the algorithm employs single-address double-width primitives. Prior lockfree algorithms for shared deques depend on the strong DCAS (Double-Compare-and-Swap) atomic primitive, not supported on most processor architectures. The new algorithm offers significant advantages over prior lock-free shared deque algorithms with respect to performance and the strength of required primitives. In turn, lock-free algorithms provide significant reliability and performance advantages over lock-based implementations.

To inline or not to inline? Enhanced inlining decisions

Abstract. The decision to inline a procedure in the Open Research Compiler (ORC) was based on a temperature heuristics that takes into consideration the time spent in a procedure and the size of the procedure. In this paper we describe the trade-off that has to be worked out to make the correct inlining decisions. We introduce two new heuristics to enhance the ORC inlining heuristics: adaptation and cycle density.With adaptation we are allowed to vary the temperature threshold and prevent penalizing small benchmarks. With cycle density we prevent the inlining of procedures that have a high temperature in spite of being called infrequently. Experiments show that while adaptation improves the speedup obtained with inlining across the SPEC2000 suite, cycle density reduces significantly both the code growth and compilation time increase caused by inlining. We then characterize the SPEC INT2000 benchmarks according to the inlining potential of their function calls. Our enhancement is released in the ORC 2.0.

Lock-Free Parallel Garbage Collection

This paper presents a lock-free parallel algorithm for garbage collection in a realistic model using synchronization primitives offered by machine architectures. Mutators and collectors can simultaneously operate on the data structure. In particular no strict alternation between usage and cleaning up is necessary, contrary to what is common in most other garbage collection algorithms. We first design and prove an algorithm with a coarse grain of atomicity and subsequently apply the reduction theorem developed to implement the higher-level atomic steps by means of the low-level primitives.

Class-level Modular Analysis for Object Oriented Languages

In this paper we address the problem of performing a class static analysis in a modular fashion, i.e. by just analyzing the class code and not the full program. In particular we show two things: the first one is how starting from a class C we can derive an approximation C to be used either as a class documentation or as a tester for a client using C; the second one is how to discover, in a fully automatic way, a class invariant. Two methods for class invariant computation are presented, proved correct and their usage is discussed