TY - GEN

T1 - How to share an object

T2 - Proceedings of the 5th IEEE Symposium on Parallel and Distributed Processing

AU - Alur, Rajeev

AU - Taubenfeld, Gadi

N1 - Copyright:
Copyright 2004 Elsevier B.V., All rights reserved.

PY - 1993

Y1 - 1993

N2 - We consider the problem of transforming a given sequential implementation of a data structure into a wait-free concurrent implementation. Given the code for different operations of an object that is designed to work under the assumption that only a single process accesses it, we want to construct an implementation that works correctly in a concurrent environment where it may be accessed by many processes. We assume a shared memory model with atomic registers. It is well known that using atomic registers it is impossible to construct concurrent implementations of even very simple objects such as test-and-set bits. However, we show that the knowledge about relative speeds of processes can be used for such implementations. We assume that there is a known upper bound on the time taken by the slowest process to execute a statement involving an access to the shared memory. This timing assumption is very powerful and enables us to construct fast wait-free implementations of data structures such as queues, stacks and synchronization primitives such as test-and-set, compare-and-swap, fetch-and-add, etc. Our transformation works only when the given sequential implementation is bounded, that is, there is a known upper bound on the number of steps required to complete any of the operations it supports. In the absence of contention, it guarantees that there is only a small overhead in the cost of executing the concurrent operations over the sequential ones, namely, only a constant number of accesses to the shared memory.

AB - We consider the problem of transforming a given sequential implementation of a data structure into a wait-free concurrent implementation. Given the code for different operations of an object that is designed to work under the assumption that only a single process accesses it, we want to construct an implementation that works correctly in a concurrent environment where it may be accessed by many processes. We assume a shared memory model with atomic registers. It is well known that using atomic registers it is impossible to construct concurrent implementations of even very simple objects such as test-and-set bits. However, we show that the knowledge about relative speeds of processes can be used for such implementations. We assume that there is a known upper bound on the time taken by the slowest process to execute a statement involving an access to the shared memory. This timing assumption is very powerful and enables us to construct fast wait-free implementations of data structures such as queues, stacks and synchronization primitives such as test-and-set, compare-and-swap, fetch-and-add, etc. Our transformation works only when the given sequential implementation is bounded, that is, there is a known upper bound on the number of steps required to complete any of the operations it supports. In the absence of contention, it guarantees that there is only a small overhead in the cost of executing the concurrent operations over the sequential ones, namely, only a constant number of accesses to the shared memory.

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

M3 - ???researchoutput.researchoutputtypes.contributiontobookanthology.conference???

AN - SCOPUS:0027866968

SN - 081864222X

T3 - Proceedings of the 5th IEEE Symposium on Parallel and Distributed Processing

SP - 470

EP - 477

BT - Proceedings of the 5th IEEE Symposium on Parallel and Distributed Processing

A2 - Anon, null

PB - Publ by IEEE

Y2 - 1 December 1993 through 4 December 1993

ER -