CCG:PLDI08

Summary

Inferring Locks for Atomic Sections. Sigmund Cherem, Trishul Chilimbi, and Sumit Gulwani. In Proceedings of the ACM Conference on Program Language Design and Implementation (PLDI 2008)., Tucson, Arizona, June 2008.
(PDF) (Slides)

Abstract

Atomic sections are a recent and popular idiom to support the development of concurrent programs. Updates performed within an atomic section should not be visible to other threads until the atomic section has been executed entirely. Traditionally, atomic sections are supported through the use of optimistic concurrency, either using a transactional memory hardware, or an equivalent software emulation (STM).

This paper explores automatically supporting atomic sections using pessimistic concurrency. We present a system that combines compiler and runtime techniques to automatically transform programs written with atomic sections into programs that only use locking primitives. To minimize contention in the transformed programs, our compiler chooses from several lock granularities, using fine-grain locks whenever it is possible.

This paper formally presents our framework, shows that our compiler is sound (i.e., it protects all shared locations accessed within atomic sections), and reports experimental results.

Bibtex entry

@INPROCEEDINGS { CCG:PLDI08,
    AUTHOR = { Sigmund Cherem and Trishul Chilimbi and Sumit Gulwani },
    TITLE = { Inferring Locks for Atomic Sections },
    BOOKTITLE = { Proceedings of the ACM Conference on Program Language Design and Implementation (PLDI 2008). },
    ADDRESS = { Tucson, Arizona },
    MONTH = { June },
    YEAR = { 2008 },
    URL = { http://www.cs.cornell.edu/w8/~siggi/getfile.php?pldi08.pdf },
    SLIDES = { http://www.cs.cornell.edu/w8/~siggi/getfile.php?pldi08.ppt },
    ABSTRACT = { Atomic sections are a recent and popular idiom to support the development of concurrent programs. Updates performed within an atomic section should not be visible to other threads until the atomic section has been executed entirely. Traditionally, atomic sections are supported through the use of optimistic concurrency, either using a transactional memory hardware, or an equivalent software emulation (STM). <br>This paper explores automatically supporting atomic sections using pessimistic concurrency. We present a system that combines compiler and runtime techniques to automatically transform programs written with atomic sections into programs that only use locking primitives. To minimize contention in the transformed programs, our compiler chooses from several lock granularities, using fine-grain locks whenever it is possible. <br>This paper formally presents our framework, shows that our compiler is sound (i.e., it protects all shared locations accessed within atomic sections), and reports experimental results. },
}