ACM Home Page
Please provide us with feedback. Feedback
A runtime system for software lock elision
Full text PdfPdf (422 KB)
Source
European Conference on Computer Systems archive
Proceedings of the 4th ACM European conference on Computer systems table of contents
Nuremberg, Germany
SESSION: Helping programmers table of contents
Pages 261-274  
Year of Publication: 2009
ISBN:978-1-60558-482-9
Authors
Amitabha Roy  University of Cambridge, Cambridge, United Kingdom
Steven Hand  University of Cambridge, Cambridge, United Kingdom
Tim Harris  Microsoft Research, Cambridge, United Kingdom
Sponsor
ACM: Association for Computing Machinery
Publisher
ACM  New York, NY, USA
Bibliometrics
Downloads (6 Weeks): 22,   Downloads (12 Months): 122,   Citation Count: 0
Additional Information:

abstract   references   index terms   collaborative colleagues  

Tools and Actions: Request Permissions Request Permissions    Review this Article  
DOI Bookmark: Use this link to bookmark this Article: http://doi.acm.org/10.1145/1519065.1519094
What is a DOI?

ABSTRACT

The advent of multi-core processors means that exploiting parallelism is key to increasing the performance of programs. Many researchers have studied the use of atomic blocks as a way to simplify the construction of scalable parallel programs. However, there is a large body of existing lock-based code, and typically it is incorrect to simply replace lock-based critical sections with atomic blocks. Some problems include the need to do IO within critical sections; the use of primitives such as condition variables; and the sometime reliance on underlying lock properties such as fairness or priority inheritance.

In this paper we investigate an alternative: a software runtime system that allows threads to speculatively execute lock-based critical sections in parallel. Execution proceeds optimistically, dynamically detecting conflicts between accesses by concurrent threads. However, if there are frequent conflicts, or if there are attempts to perform operations that cannot be done speculatively, then execution can fall back to acquiring a lock. Conversely, implementations of atomic blocks must typically serialise all operations that cannot be performed speculatively.

Our runtime system has been designed with the requirements of systems code in mind: in particular it does not require that programs be written in type-safe languages, nor does it require any form of garbage collection. Furthermore, we never require a thread holding a lock to wait for a thread that has speculatively acquired it. This lets us retain any useful underlying properties of a given lock implementation, e.g. fairness or priority inheritance.


REFERENCES

Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references.

1
2
 
3
4
 
5
Chi Cao Minh, JaeWoong Chung, Christos Kozyrakis, and Kunle Olukotun. STAMP: Stanford transactional applications for multi-processing. In IISWC '08: Proc. IEEE International Symposium on Workload Characterization, pages 35--46, September 2008.
 
6
Dave Dice, Ori Shalev, and Nir Shavit. Transactional locking II. In DISC '06: Proc. 20th International Symposium on Distributed Computing, pages 194--208, September 2006.
 
7
Keir Fraser. Practical lock freedom. PhD thesis, Cambridge University Computer Laboratory, 2003. Also available as Technical Report UCAM-CL-TR-579.
8
9
10
11
12
 
13
Jim Larus and Ravi Rajwar. Transactional Memory. Morgan & Claypool Publishers, 2007.
14
 
15
Virendra J. Marathe, Michael F. Spear, Christopher Heriot, Athul Acharya, David Eisenstat, William N. Scherer, III, and Michael L. Scott. Lowering the overhead of software transactional memory. Technical Report TR 893, Computer Science Department, University of Rochester, March 2006.
 
16
Vijay Menon, Steven Balensiefer, Tatiana Shpeisman, Ali-Reza Adl-Tabatabai, Richard Hudson, Bratin Saha, and Adam Welc. Single global lock semantics in a weakly atomic S™. In TRANSACT '08, 3rd ACM SIGPLAN Workshop on Languages, Compilers, and Hardware Support for Transactional Computing, February 2008.
 
17
Vijay Menon, Steven Balensiefer, Tatiana Shpeisman, Ali-Reza Adl-Tabatabai, Richard L. Hudson, Bratin Saha, and Adam Welc. Towards a lock-based semantics for Java S™. Technical Report UW-CSE-07-11-01, University of Washington, Nov 2007.
 
18
 
19
Kevin E. Moore, Jayaram Bobba, Michelle J. Moravan, Mark D. Hill, and David A. Wood. Log™: Log-based transactional memory. In Proc. 12th International Symposium on High-Performance Computer Architecture, pages 254--265. February 2006.
 
20
 
21
 
22
Torvald Riegel and Diogo Becker de Brum. Making object-based S™ practical in unmanaged environments. In TRANSACT '08, 3rd ACM SIGPLAN Workshop on Languages, Compilers, and Hardware Support for Transactional Computing, February 2008.
23
 
24
Amitabha Roy, Steven Hand, and Tim Harris. Exploring the Limits of Disjoint Access Parallelism. In Proceedings of HotPar '09: 1st USENIX Workshop on Hot Topics in Parallelism (to appear), March 2009.
25
 
26
Michael F. Spear, Virendra J. Marathe, Luke Dalessandro, and Michael L. Scott. Privatization techniques for software transactional memory. Technical Report TR 915, Computer Science Department, University of Rochester, February 2007.
 
27
Michael F. Spear, Maged M. Michael, and Michael L. Scott. Inevitability mechanisms for software transactional memory. In TRANSACT '08: Proc 3rd ACM SIGPLAN Workshop on Transactional Computing. February 2008.
 
28
 
29
Yin Wang, Terence Kelly, Manjunath Kudlur, Stéphane Lafortune, and Scott A. Mahlke. Gadara: Dynamic deadlock avoidance for multithreaded programs. In OSDI '08: Proceedings of the 8th USENIX Symposium on Operating Systems Design and Implementation, pages 281--294, 2008.
30
 
31

Collaborative Colleagues:
Amitabha Roy: colleagues
Steven Hand: colleagues
Tim Harris: colleagues