Locking without blocking

Making lock based concurrent data structure algorithms nonblocking

John Turek, Dennis Shasha, Sundeep Prakash

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

Nonblocking algorithms for concurrent data structures guarantee that a data structure is always accessible. This is in contrast to blocking algorithms in which a slow or halted process can render part or all of the data structure inaccessible to other processes. This paper proposes a technique that can convert most existing lock-based blocking data structure algorithms into nonblocking algorithms with the same functionality. Our instruction-by-instruction transformation can be applied to any algorithm having the following properties: Interprocess synchronization is established solely through the use of locks; There is no possibility of deadlock (e.g. because of a well-ordering among the lock requests). In contrast to previous work, our transformation requires only a constant amount of overhead per operation and, in the absence of failures, it incurs no penalty in the amount of concurrency that was available in the original data structure. The techniques in this paper may obviate the need for a wholesale reinvention of techniques for nonblocking concurrent data structure algorithms.

Original languageEnglish (US)
Title of host publicationProceedings of the ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems
Editors Anon
PublisherPubl by ACM
Pages212-222
Number of pages11
ISBN (Print)0897915194
StatePublished - 1992
EventProceedings of the 11th ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems - San Diego, CA, USA
Duration: Jun 2 1992Jun 4 1992

Other

OtherProceedings of the 11th ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems
CitySan Diego, CA, USA
Period6/2/926/4/92

Fingerprint

Data structures
Synchronization

ASJC Scopus subject areas

  • Software

Cite this

Turek, J., Shasha, D., & Prakash, S. (1992). Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. In Anon (Ed.), Proceedings of the ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems (pp. 212-222). Publ by ACM.

Locking without blocking : Making lock based concurrent data structure algorithms nonblocking. / Turek, John; Shasha, Dennis; Prakash, Sundeep.

Proceedings of the ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems. ed. / Anon. Publ by ACM, 1992. p. 212-222.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Turek, J, Shasha, D & Prakash, S 1992, Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. in Anon (ed.), Proceedings of the ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems. Publ by ACM, pp. 212-222, Proceedings of the 11th ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems, San Diego, CA, USA, 6/2/92.
Turek J, Shasha D, Prakash S. Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. In Anon, editor, Proceedings of the ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems. Publ by ACM. 1992. p. 212-222
Turek, John ; Shasha, Dennis ; Prakash, Sundeep. / Locking without blocking : Making lock based concurrent data structure algorithms nonblocking. Proceedings of the ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems. editor / Anon. Publ by ACM, 1992. pp. 212-222
@inproceedings{bb581ad72a4e43c09adc7b06144235c0,
title = "Locking without blocking: Making lock based concurrent data structure algorithms nonblocking",
abstract = "Nonblocking algorithms for concurrent data structures guarantee that a data structure is always accessible. This is in contrast to blocking algorithms in which a slow or halted process can render part or all of the data structure inaccessible to other processes. This paper proposes a technique that can convert most existing lock-based blocking data structure algorithms into nonblocking algorithms with the same functionality. Our instruction-by-instruction transformation can be applied to any algorithm having the following properties: Interprocess synchronization is established solely through the use of locks; There is no possibility of deadlock (e.g. because of a well-ordering among the lock requests). In contrast to previous work, our transformation requires only a constant amount of overhead per operation and, in the absence of failures, it incurs no penalty in the amount of concurrency that was available in the original data structure. The techniques in this paper may obviate the need for a wholesale reinvention of techniques for nonblocking concurrent data structure algorithms.",
author = "John Turek and Dennis Shasha and Sundeep Prakash",
year = "1992",
language = "English (US)",
isbn = "0897915194",
pages = "212--222",
editor = "Anon",
booktitle = "Proceedings of the ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems",
publisher = "Publ by ACM",

}

TY - GEN

T1 - Locking without blocking

T2 - Making lock based concurrent data structure algorithms nonblocking

AU - Turek, John

AU - Shasha, Dennis

AU - Prakash, Sundeep

PY - 1992

Y1 - 1992

N2 - Nonblocking algorithms for concurrent data structures guarantee that a data structure is always accessible. This is in contrast to blocking algorithms in which a slow or halted process can render part or all of the data structure inaccessible to other processes. This paper proposes a technique that can convert most existing lock-based blocking data structure algorithms into nonblocking algorithms with the same functionality. Our instruction-by-instruction transformation can be applied to any algorithm having the following properties: Interprocess synchronization is established solely through the use of locks; There is no possibility of deadlock (e.g. because of a well-ordering among the lock requests). In contrast to previous work, our transformation requires only a constant amount of overhead per operation and, in the absence of failures, it incurs no penalty in the amount of concurrency that was available in the original data structure. The techniques in this paper may obviate the need for a wholesale reinvention of techniques for nonblocking concurrent data structure algorithms.

AB - Nonblocking algorithms for concurrent data structures guarantee that a data structure is always accessible. This is in contrast to blocking algorithms in which a slow or halted process can render part or all of the data structure inaccessible to other processes. This paper proposes a technique that can convert most existing lock-based blocking data structure algorithms into nonblocking algorithms with the same functionality. Our instruction-by-instruction transformation can be applied to any algorithm having the following properties: Interprocess synchronization is established solely through the use of locks; There is no possibility of deadlock (e.g. because of a well-ordering among the lock requests). In contrast to previous work, our transformation requires only a constant amount of overhead per operation and, in the absence of failures, it incurs no penalty in the amount of concurrency that was available in the original data structure. The techniques in this paper may obviate the need for a wholesale reinvention of techniques for nonblocking concurrent data structure algorithms.

UR - http://www.scopus.com/inward/record.url?scp=0026965767&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=0026965767&partnerID=8YFLogxK

M3 - Conference contribution

SN - 0897915194

SP - 212

EP - 222

BT - Proceedings of the ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems

A2 - Anon, null

PB - Publ by ACM

ER -