John Turek, Dennis Shasha, and Sundeep Prakash. Locking without Blocking: Making Lock-Based Concurrent Data Structure Algorithms Nonblocking. In Proceedings of the 11th ACM Symposium on Principles of Database Systems, pages 212--222, June 1992. (p 19)  Home/Search   Document Not in Database   Summary   Related Articles   Check

....allows the development of wait free data structures. In these algorithms, processes carefully install specifications of the work they intend to do in shared data structures, and processes which are capable of executing take turns completing part of other processes work. Turek, Shasha and Prakesh [81] also follow this technique, providing a more general mechanism for replacing a critical section, and the code executed therein, with a wait free data structure in which the unfinished work of all interested parties is represented, and again progressing processes help complete work for slow or ....

J. Turek, D. Shasha, and S. Prakash. Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. In Proc. of the ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems, June 1992.

....section is left in an inconsistent state resulting in application failure. Locking algorithms can be modified to address these limitations but require significant effort and creativity from the programmer. Software proposals have been made to make lock based critical sections non blocking [163] and thread scheduling that is aware of blocking locks [87, 123] Bohannon et al. present a recovery strategy to allow a system to recover from a lock held by a process believed to have failed [20] Locks also restrict parallelism: two operations on the same object cannot execute in parallel, ....

John Turek, Dennis Shasha, and Sundeep Prakash. Locking Without Blocking: Making Lock Based Concurrent Data Structure Algorithms Nonblocking. In Proceedings of the 11th ACM Symposium on Principles of Distributed Computing, pages 212--222, August 1992.

....non blocking structures. Alemany et al. 1] and LaMarca [19] proposed techniques to reduce the inefficiencies in applying this methodology to large objects at the cost of more communication between the application process and the operating system. Other methods to improve this were proposed in [4, 32]. Prakash et al. 26] and Turek et al. 32] presented techniques to transform multiplelock concurrent objects into lock free objects. However, it was shown that their transformed algorithms are less efficient than the corresponding lock based algorithms [15, 19, 30] These authors are concerned ....

....and LaMarca [19] proposed techniques to reduce the inefficiencies in applying this methodology to large objects at the cost of more communication between the application process and the operating system. Other methods to improve this were proposed in [4, 32] Prakash et al. 26] and Turek et al. [32] presented techniques to transform multiplelock concurrent objects into lock free objects. However, it was shown that their transformed algorithms are less efficient than the corresponding lock based algorithms [15, 19, 30] These authors are concerned with transforming sequential objects to ....

John Turek, Dennis Shasha, and Sundeep Prakash. Locking without blocking: making lock based concurrent data structure algorithms nonblocking. In ACM Proceedings of the Principles of Database Systems, pages 212--222, 1992.

....acquire and release operations from an execution stream but requires lock acquisitions in the presence of conflicts. Improving performance of software non blocking schemes have been studied previously [27, 4, 38] Software proposals have been made to make lock based critical sections non blocking [37] and thread scheduling that is aware of blocking locks [18, 28] Database concurrency control. Transactions are well understood and studied in database literature [10] The use of timestamps for resolving conflicts and ordering transactions in database systems has been well studied [5, 32] ....

J. Turek, D. Shasha, and S. Prakash. Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. In Proceedings of the 11th ACM Symposium on Principles of Distributed Computing, pages 212--222, Aug. 1992.

....of a data structure has been considered a publishable result. Several important data structures (such as priority queues) still have no known practical non blocking implementations. The conceptual complexity of non blocking algorithms can be overcome by using universal translation protocols (e.g. [39, 2, 99, 14, 54, 52, 4, 3, 87, 74, 1, 49, 50]) to convert mechanically from a well understood sequential specification to a provably equivalent non blocking algorithm 1 . Such protocols exist and can provide non blocking implementations of any data structure. Unfortunately, as noted by many (e.g. 39, 54, 87, 69] the average performance ....

....to support this are unclear. In contrast, our implementation of linked lists is general, and is usable by arbitrary application code, assuming they support and that DCAS is available. 4.7. RELATED WORK 115 4.7. 2 General Methodologies for Implementing Concurrent Data Objects Barnes [14] Turek [99], Valois [100] Israeli and Rappaport [46, 47] and others provide techniques for increasing the concurrency with non blocking synchronization. However, these concurrent updates have noticeable algorithmic cost and often increase memory contention. These costs appear to outweigh the actual ....

[Article contains additional citation context not shown here]

Turek, J., D. Shasha, and S. Prakash. "Locking without blocking: Making Lock-Based Concurrent Data Structure Algorithms Non-Blocking." In Proceedings of the 1992 Principles of Database Systems, Pages 212--222, 1992.

....then some process (not necessarily p) will eventually complete its operation. Lock free implementations are hard to design and prove correct. Consequently, instead of inventing separate implementations for di#erent types of objects, recent research has focussed mostly on universal constructions [11, 21, 12, 18, 23, 8, 13, 16, 1, 22, 5, 4, 6, 2, 20]. A (non blocking or waitfree) universal construction for n processes is an algorithm that, when instantiated with the sequential implementation 1 of any type T , becomes a (non blocking or wait free) implementation of a type T object that can be accessed concurrently by n processes [12] In this ....

Turek, J., Shasha, D., and Prakash, S. Locking without blocking: Making lock-based concurrent data structure algorithms non-blocking. In Proceedings of the 11th Symposium on Principles of Database Systems (1992), pp. 212--222.

....are free of the pitfalls, such as convoying, priority inversion, and deadlocks, that afflict lock based implementations. However, wait free implementations are notoriously hard to design and prove correct. To overcome this di#culty, recent research has focussed on universal constructions [1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 14, 19, 20, 21, 22] A universal construction for n processes is an algorithm that, when instantiated with the sequential implementation 1 of any type T , becomes a wait free implementation of a type T object that can be accessed concurrently by n processes [9] Thus, once we have an e#cient universal construction ....

.... first universal construction are due to Herlihy [8, 9] The use of LL and SC in universal constructions was also introduced by Herlihy [10] Of the recent universal constructions, some focus on improving the time complexity when concurrent operations access disjoint parts of the implemented object [2, 5, 6, 7, 11, 19, 21, 22]. Others focus on reducing the worstcase time complexity [1] Afek, Weisberger, and Weisman present polynomial time implementations of some objects at Level 2 of the consensus hierarchy, including fetch add and swap objects, from 2 consensus objects [3] Some fast type specific implementations are ....

Turek, J., Shasha, D., and Prakash, S. Locking without blocking: Making lock-based concurrent data structure algorithms non-blocking. In Proceedings of the 11th Symposium on Principles of Database Systems

....and a high level of concurrency. That is, operations that access disjoint parts of the data structure, or are widely separated in time, should not interfere with each other. For example, operations on disjoint sets of components can proceed independently, and avoid concurrency control overhead [Bar93, IR94, TSP92, ST95, AM95a]. When there is considerable contention, conflicting operations could form long chains and complex webs, transitively effecting operations that are otherwise disjoint. Extremely fast algorithms might be designed that disentangle these webs, and require coordination only among local neighborhoods ....

.... effecting the shared memory, and then to apply the changes atomically using a non blocking implementation of a multi word RMW [Bar93] This idea was developed further by Israeli and Rappoport [IR94] Turek, Shasha, and Prakash explored similar constructions using an atomic compare swap primitive [TSP92]. These non blocking algorithms avoid copying the entire data structure, and allow disjoint access: operations in disjoint portions of the conflict graph can proceed independently. Processes waiting for each other recursively can form long chains of size n. Shavit and Touitou present a ....

J. Turek, D. Shasha, and S. Prakash. Locking without blocking: Making lock based concurrent data structure algorithms non-blocking. In Proceedings of the 1992 Conference on the Principles of Database Systems, pages 212-222, 1992.

....of this method was suggested by Alemany and Felten in [1] but it relies on support from the operating system to identify slow processes. Furthermore, although their improvement saves copying, it is still inherently sequential and does not allow parallelism. Turek, Shasha and Parkash in [22] show a general method for transforming a concurrent implementation of a data structure into a non blocking one. A process being blocked due to some lock held by another process helps the blocking process until it releases its lock. The help continues recursively if the blocking process is also ....

....concurrently on the data structure if they do not contend. Barnes method is very similar to the implementation of k ary operations suggested in [13, 20] Again, like [13, 20] it can be shown that its sensitivity is high. The algorithm we present uses the concept of mutual helping introduced in [22], and uses the same scheme as in [20] and [13] However, unlike these works, the algorithm minimizes the radius of influence each operation causes, that is, decreases the sensitivity of the implementation and increases parallelism. Two works are related to our lower bounds. Linial, in [16] ....

J. Turek, D. Shasha and S. Prakash, "Locking without Blocking: Making Lock Based Concurrent Data Structure Algorithms Nonblocking", ACM SIGACT-SIGMOD Symp. on Principles of Database Systems, pp. 212--222, June 1992.

....requires two writes: one write to attach the new element and one write to move the tail pointer. If an operation detects that it is blocked by a half finished operation, the new operation will altruistically complete the half finished operation and unblock itself. Turek, Shasha, and Prakash [22] propose a general transformation for creating non blocking data structure algorithms from lock based data structure algorithms. Instead of setting a lock, a process posts a pointer to its own program. If a process finds that it is blocked because some other process has set a lock , the blocked ....

....data structure such as a queue has only a few states, and is easy to specify. A more complex structure, such as a linked list or a binary search tree, is much harder to describe. For these data structures a more powerful technique, one which explicitly specifies the cleanup actions, is needed. In [22], Turek et al. propose a method for transforming locking data structures into non blocking data structures. The key to the transformation is to post a continuation instead of a lock. The continuation contains the modifications that the process intends to perform. If a process attempts to post a ....

J. Turek, D. Shasha, and S. Prakash. Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. In ACM Symp. on Principles of Database Systems, pages 212--222, 1992. 20

....architectures, e.g. 23, 26] The algorithm can be extended to rely on other unary universal operations; in particular, the O(1) implementation of LL SC from compare swap [3] can be employed. The core of the algorithm implements the binary operation in a manner similar to known algorithms [3, 7, 19, 25, 27]: A processor locks the words in the data set of the binary operation, applies the operation, and then unlocks the data set. Operations help each other to complete, thus ensuring that the algorithm does not block. The new feature of our algorithm is that a processor may lock its data set in two ....

....complexity of k compare swap and k SC operations. Analysis of all three implementations shows that they are very sensitive to contention by distant operations. For example, two operations executing on two ends of a linked list can increase each other s step complexity. Turek, Shasha and Prakash [27] show a general method for transforming a concurrent implementation of a data structure into a non blocking one; their method employs compare swap. A process being blocked due to some lock held by another process helps the blocking process until it releases its lock; help continues recursively ....

[Article contains additional citation context not shown here]

J. Turek, D. Shasha, and S. Prakash. Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. In Proceedings of the 11th Annual ACM Symposium on Principles of Database Systems, pages 212--222, 1992.

....Herlihy s methodologies using extra communication between the operating system kernel and application processes. Barnes [5] presented a similar general methodology in which processes record and timestamp their modifications to the shared object, and cooperate whenever conflicts arise. Turek et al. [23] and Prakash et al. 20] presented methodologies for transforming multiple lock concurrent objects into lock free concurrent objects. In comparison to data structure specific non blocking algorithms, these general methodologies tend to be inefficient, with significant overheads for copying and or ....

J. Turek, D. Shasha, and S. Prakash. Locking without Blocking: Making Lock Based Concurrent Data Structure Algorithms Nonblocking. In Proceedings of the Eleventh ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems, pages 212--222, 1992.

....the execution speeds of other processes. Herlihy s universal wait free object construction has been regarded as very expensive to implement, and many researchers (including Herlihy) have proposed more efficient techniques based on a weaker synchronization technique called non blocking [5] 8] [15]. A non blocking concurrent system guarantees that at least one process can complete any operation in a finite number of steps, regardless of the execution speeds of other processes. There has also been work which focuses on providing hardware support [6] and operating system support [21] to ....

....copying entire objects, but it is not completely clear how this can be implemented. 2.3 Turek, Shasha, and Prakash s Approach. Turek, Shasha, and Prakash describe a method for instruction by instruction translation of lockbased concurrent data structure algorithms into nonblocking algorithms [15]. Their approach avoids the copying step of Herlihy s method by establishing the notion of a continuation with concurrent operations. A continuation is a data structure associated with the execution of an operation which maintains sufficient state information to complete the execution of that ....

Turek, J., Shasha, D., Prakash, S. Locking without Blocking: Making Lock Based Concurrent Data Structure Algorithms Nonblocking. In Proceedings of 11th Principles of Database Systems (June 1992, San Diego, CA). ACM Press, pp. 212-222.

....TRUE 4 else 5 return FALSE END ATOMIC Figure 1: The Compare Swap synchronization primitive. primitive is one that can solve the consensus problem [7] for any number of processes; Compare Swap is a universal primitive. The first universal method was given by Herlihy [13] many others followed [1, 4, 11, 22, 26]. However, it has become increasingly apparent that universal methods suffer from several sources of inefficiency, such as wasted parallelism, excessive copying, and generally high overhead. In addition to the universal methods, algorithms have also been developed for lock free objects that are ....

J. Turek, D. Shasha, and S. Prakash. Locking without blocking: Making lock based concurrent data strucuture algorithms nonblocking. In Proceedings of the Eleventh Symposium on Principles of Database Systems, 1992.

....implements a k word compare and swap using load linked store conditional. Also, Anderson and Moir [5] presented non blocking methodologies for large objects that rely on techniques for implementing multipleword compare and swap using load linked store conditional and vice versa. Turek et al. [40] and Prakash et al. 31] presented methodologies for transforming multiple lock concurrent objects into lock free concurrent objects. Unfortunately, the performance of non blocking algorithms resulting from general methodologies is acknowledged to be significantly inferior to that of the ....

J. Turek, D. Shasha, and S. Prakash. Locking Without Blocking: Making Lock Based Concurrent Data Structure Algorithms Nonblocking. In Proceedings of the Eleventh ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems, pages 212--222, Vancouver, BC, Canada, August 1992.

....the update without affecting the shared memory and then to apply the changes atomically using a non blocking implementation of a multi word Read modify write are presented. This idea was developed further in [IR94] Similar constructions using an atomic compare swap primitive are explored in [TSP92]. These non blocking algorithms avoid copying the entire data structure, and allow disjoint access: independent operations can proceed independently. However, processes helping each other recursively can form long helping chains of size n. A non blocking implementation of multi word atomic ....

Turek, J., Shasha, D. and Prakash, S. Locking Without Blocking: Making Lock Based Concurrent Data Structure Algorithms Non-blocking. In Proceedings of the 1992 Conference on the Principles of Database Systems, pages 212-222, 1992.

....will make progress within a bounded number of time steps. Treiber [21] presents an algorithm that is non blocking but inefficient: a dequeue operation takes time proportional to the number of the elements in the queue. Herlihy [6] Prakash, Lee, and Johnson [15] Turek, Shasha, and Prakash [22]; and Barnes [2] propose general methodologies for generating non blocking versions of sequential or concurrent lock based algorithms. However, the resulting implementations are generally inefficient compared to specialized algorithms. Massalin and Pu [10] present lock free algorithms based on a ....

J. Turek, D. Shasha, and S. Prakash. Locking without Blocking: Making Lock Based Concurrent Data Structure Algorithms Nonblocking. In Proceedings of the 11th ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems, pages 212--222, 1992.

....has been proposed by Ladin et al. for replicating servers [14] Replicas communicate information among themselves by lazily exchanging gossip messages. Several authors have explored the construction of non blocking and wait free concurrent data structures in a shared memory environment [7, 19]. These algorithms enhance concurrency because a slow operation never blocks a fast operation. In a previous paper, we have proposed fixed copy and variable copy algorithms for lazy updates on a distributed B tree and provided a theoretical framework for replication [10] Lazy update algorithms ....

Turek J., Shasha D., and Prakash S. Locking without Blocking: Making Lock Based Concurrent Data Structure Algorithms Nonblocking, ACM Symposium on Principles of Database Systems, 1992, pp. 212-222.

....than the one originally read. This will occur if Old is removed from the data structure, then re inserted as Current with a new object. This sequence of events cannot be detected by the Compare Swap and is known as the A B A problem. Following the work of Prakash et al. 22] and Turek et al. [27], we make use of a double word Compare Swap instruction [21] to avoid this problem. A counter is appended to Current which is treated as a part of Current. Thus Current consists of two parts: the value part of Current and the counter part of Current. This counter is incremented every time a ....

....portion of the pointer itself has into two parts: one bit of the counter called the Dq bit is used to indicate whether the queuing element is in the queue. The rest of the bits are used as the actual counter. This technique is similar to the one used by Prakash et al. 22] and Turek et al. [27]. Their counter refers to the record referenced by the pointer. In our algorithm, the counter refers to the record that contains the pointer, not the record that is pointed to. If the Dq bit of a record q is FALSE, then the record is in the queue for a lock L. If the Dq bit is TRUE, then the ....

J. Turek, D. Shasha, and S. Prakash. Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. In ACM Symp. on Principles of Database Systems, pages 212--222, 1992.

....to ensure correctness in spite of concurrent accesses. Nonlocking algorithms have the attractive property that they avoid busy waiting, which can degrade performance [1, 6] These algorithms typically use the compare and swap or the compare and swap double instruction to commit modifications [8, 16, 18, 19], although some algorithms use the fetch and add instruction [7] The correctness of the DTG algorithms depends on the atomicity of the hash table operations. Fortunately, many practical non locking list and search structure algorithms exist in the literature [16, 19] One place where care must be ....

J. Turek, D. Shasha, and S. Prakash. Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. In ACM Symp. on Principles of Database Systems, pages 212--222, 1992.

....data structures (see, for example, Her88, Her89] In these techniques, also motivated by similar concerns about process failure and slowdown, a process attempts to take a data structure from one consistent state to another with a single compare and swap instruction. Turek, Shasha and Prakesh [TSP92] show a general technique for making a class of algorithms resilient to process failure. Both techniques require rewriting all concurrent data structures using a different paradigm, and require architectures with compare and swap instructions. Our work is aimed at providing similar ....

J. Turek, D. Shasha, and S. Prakash. Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. In Proc. Principles of Database Sys., June 1992.

....implements a k word compare and swap using load linked store conditional. Also, Anderson and Moir [2] presented non blocking methodologies for large objects that rely on techniques for implementing multipleword compare and swap using load linked store conditional and vice versa. Turek et al. [39] and Prakash et al. 30] presented methodologies for transforming multiple lock concurrent objects into lock free concurrent objects. Unfortunately, the performance of non blocking algorithms resulting from general methodologies is acknowledged to be significantly inferior to that of the ....

J. Turek, D. Shasha, and S. Prakash. Locking without Blocking: Making Lock Based Concurrent Data Structure Algorithms Nonblocking. In Proceedings of the 11th ACM Symposium on Principles of Database Systems, pages 212--222, Vancouver, BC, Canada, August 1992.

....take advantage of its simplicity; these mechanisms are described in Section 7.2. The latch recovery techniques are based on work in [9] A significant body of work on making data structures tolerant to process slow downs and failures exists under the title of wait free data structures (see e.g. [20, 21, 44]) This work is not designed for transaction processing systems, however, and depends on the presence of a compare and swap instruction, which is not available in many architectures (such as SPARC) Sullivan and Stonebraker address the problem of protection from erroneous writes in [43] but they ....

J. Turek, D. Shasha, and S. Prakash. Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. In Proc. of the ACM SIGACT-SIGMODSIGART Symposium on Principles of Database Systems, June 1992.

No context found.

John Turek, Dennis Shasha, and Sundeep Prakash. Locking without Blocking: Making Lock-Based Concurrent Data Structure Algorithms Nonblocking. In Proceedings of the 11th ACM Symposium on Principles of Database Systems, pages 212--222, June 1992. (p 19)

No context found.

J. Turek, D. Shasha, and S. Prakash, "Locking Without Blocking: Making Lock Based Concurrent Data Structure Algorithms Non-Blocking", Proceedings of the 11th Symposium on Principles of Database Systems, 1992, pp. 212-222.

First 50 documents

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC