Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proc. of the 27th Ann. ACM Symp. on Theory of Computing, pages 538--547, May 1995.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....that allow easy implementation of lock free objects. A universal construction is used to automatically generate lock free implementations of arbitrary objects from their sequential implementations. Universal constructions were proposed first by Herlihy [36] and improved later by others [2, 7, 20, 37, 42]. To implement a lock free object using a universal construction, a programmer first writes code for a sequential implementation of that object. This code is then embedded within a retry loop that is automatically generated by the universal construction. Alock free implementation that is based on ....

....in Buf (lines 21 and 22) it is preempted by T 2 . T 1 is enabled to write into Buf [3] at the preemption point. Insets (b) and (c) show the relevant variables at the beginning and at the end of operation m 2 , respectively. T 2 successfully changes CV by writing its new value (65) into Val[2] and by writing its task identifier (2) into all components of Buf . Before returning, T 2 writes true into all components of Pm to inform lower priority tasks that their operations havebeeninterfered with. Inset (d) shows the relevantvariables at the termination of m 0 . ObservethatCV does not ....

[Article contains additional citation context not shown here]

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast (extended abstract). In Proceedings of the 27th Annual ACM Symposium on Theory of Computing, pages 538-- 547. ACM, 1995.

....resp. the Diffracting Tree. Is waiting therefore a good ingredient when a system should have good expected performance and we don t care about the worst case Indeed, there has been a tremendous amount of research in wait free (or block free) distributed data structures (see [Lam83, HT90, Her91, ADT95, MT97] among others) This research, however, was done in a shared memory model, which differs significantly from our message passing model such that the notion of waiting is completely unlike ours. In shared memory, a wait free implementation guarantees that a processor must not wait for another ....

Yehuda Afek, Dalia Dauber, and Dan Touitou. Wait-free made fast. In Proceedings of the 27th Annual ACM Symposium on the Theory of Computing, pages 538--547, New York, May 1995.

.... steps taken by a process depends on the contention, the number of processes that try to enter the critical section at the same time (the notion of adaptiveness is de ned in Section 2) Many papers on adaptive implementations of mutual exclusion and other shared objects were published since then [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]. While an adaptive mutual exclusion algorithm is presented in this thesis, most of the thesis deals with adaptive implementations of wait free long lived objects. In the wait free model, up to N 1 processes out of N may fail; Still the remaining working processes must nish the task. In other ....

....that operation. In other words, the complexity of an operation is a function of the actual contention it encounters and not of the total number of processes or any bound on the number of active processes . The strongest form of adaptiveness in the read write shared memory What Lamport and [13] call fast others call adaptive [18] Moir and Anderson [14, 17, 16, 15] have used the term fast to denote algorithms whose complexity is a function of an a priori known upper bound on the number of processes that may concurrently access the object. ....

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proc. of the 27th Ann. ACM Symp. on Theory of Computing, pages 538-547, May 1995. 11

....if processes are subject to random halting failures. Because the algorithm s performance depends only on the number of processes actually executing the protocol and not on the total number of processes in the system, it is adaptive in the sense of [11] which implies it is fast in the sense of [2, 25]. Thus it is well suited to situations where only one or a few processes attempt to run the algorithm at the same time. Our noisy scheduling model is similar to the model used by Gafni and Mitzenmacher [23] in their analysis of mutual exclusion protocols with random timing, but is extended to ....

....adversary is much stronger than one limited to noisy scheduling. It seems likely that a better upper bound than O(f log n) could be obtained by a more careful analysis that includes how processes change preferences; we conjecture that the real bound is in fact O(log n) exponential(1) uniform [0,2] geometric(0.5) 0.5 exponential(0.5) 2 3,4 3 normal(1,0.04) Mean round of rst termination 100000 10000 1000 100 10 1 14 12 10 8 6 4 2 Figure 1: Results of simulating LEAN CONSENSUS with various interarrival distributions. Statistical adversaries. We would also like to do away ....

Yehuda Afek, Dalia Dauber, and Dan Touitou. Wait-free made fast (extended abstract). In Proceedings of the Twenty-Seventh Annual ACM Symposium on the Theory of Computing, pages 538-547, Las Vegas, Nevada, 29 May{1 June 1995.

....if processes are subject to random halting failures. Because the algorithm s performance depends only on the number of processes actually executing the protocol and not on the total number of processes in the system, it is adaptive in the sense of [11] which implies it is fast in the sense of [2, 25]. Thus it is well suited to situations where only one or a few processes attempt to run the algorithm at the same time. Our noisy scheduling model is similar to the model used by Gafni and Mitzenmacher [23] in their analysis of mutual exclusion protocols with random timing, but is extended to ....

....same except for a small random epsilon, generated uniformly in the range (0; 10 8 ) In each case, half the processes are started with input 0 and half with input 1. There are no failures. The random number generator used was drand48. The distributions used were: 18 exponential(1) uniform [0,2] geometric(0.5) 0.5 exponential(0.5) 2 3,4 3 normal(1,0.04) Mean round of rst termination 100000 10000 1000 100 10 1 14 12 10 8 6 4 2 Figure 1: Results of simulating lean consensus with various interarrival distributions. 1. Normal distribution with mean 1 and standard deviation ....

Yehuda Afek, Dalia Dauber, and Dan Touitou. Wait-free made fast (extended abstract). In Proceedings of the Twenty-Seventh Annual ACM Symposium on the Theory of Computing, pages 538-547, Las Vegas, Nevada, 29 May{1 June 1995.

....in turn, is used in a collect algorithm [5] with O(k 3 ) step complexity, where k is the current contention. This collect algorithm is used to extend our immediate snapshot algorithm to be long lived and adapt to current contention [6] with O(k 4 ) step complexity) Afek, Dauber and Touitou [3] introduce general methods for implementations of long lived objects, whose step complexity is linear in the current contention; however, they use strong load linked and store conditional operations. Lamport [23] suggests a mutual exclusion algorithm which requires a constant number of steps when ....

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proc. 27th ACM Symp. Theory of Comp., pages 538--547, 1995.

....1998) pp. 277 286. 2 Department of Computer Science, The Technion, Haifa 32000, Israel (hagit cs.technion.ac.il, leonf cs.technion.ac.il) Supported by the fund for the promotion of research at the Technion. 1 Moir and Anderson [27] use the term fast , which conflicts with other papers [3, 25]. 1 2 Attiya and Fouren (Algorithm 6) O(k) union [23] O(k log k) lattice agreement (Algorithm 5) O(k) O(k 2 ) renaming [27] Algorithm 1) O(k log k) Algorithm 4) 6k Gamma 1) renaming (Algorithm 2) 2k Gamma 1) renaming O(n log n) Algorithm 3) 2k Gamma 1) renaming O(N) ....

....if a 4 Attiya and Fouren process ever performs a step then it influences the step complexity of the algorithm throughout the execution. More useful are algorithms which adapt to the current contention and whose step complexity decreases when processes stop participating. Afek, Dauber and Touitou [3] present implementations of long lived objects which adapt to the current contention; they use load linked and store conditional operations. Recent papers present algorithms for long lived renaming [2, 14] collect [6] and snapshots [7] which adapt to the current contention using only read write ....

[Article contains additional citation context not shown here]

Y. Afek, D. Dauber, and D. Touitou, Wait-free made fast, in Proc. 27th ACM Symp. Theory of Comp., 1995, pp. 538--547.

....in each step, can read all of the shared memory and update it in arbitrary ways. Further, the lower bound holds even if each process is restricted to applying only one operation on the universal construction. Finally, the lower bound is tight: some existing wait free universal constructions [12, 13, 1] have O(n) worst case time complexity. # This work is partially supported by NSF RIA grant CCR9410421. 1 Introduction In asynchronous multiprocess systems, software implementations of shared objects are typically based on locking. Since locking has several drawbacks, such as convoying, priority ....

....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 ....

[Article contains additional citation context not shown here]

Afek, Y., Dauber, D., and Touitou, D. Wait-free made fast. In Proceedings of the 27th Annual ACM Symposium on Theory of Computing (1995), pp. 538-- 547.

....[10, 1] is an important property for good performance. To achieve adaptiveness in our GRASP solution, we must use a wait free transaction implementation whose time complexity is a function of the number of active processes and of the amount of data accessed by the transaction. The construction of [2] has this property, but is not disjoint access parallel. 7 Concluding Remarks We have presented a very general synchronization problem and a solution to this problem. This work serves two purposes. First, it uni es many well known synchronization problems, and helps to clarify the relationships ....

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proceedings of the 27th Annual ACM Symposium on Theory of Computing, pages 538{ 547, 1995.

....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 ....

....Contention sensitive time complexity The contention experienced by op, denoted by nc , is the number of processes that have operations concurrent with op. Ideally, if an operation experiences low contention (i.e. nc n) its time complexity should be smaller than the worst case time complexity [1]. More precisely, the time complexity of an operation should be a function of nc , not of n. Afek, Dauber, and Touitou defined and achieved this property in their universal construction [1] 1.4 The result and its significance We present an n process construction that, when instantiated with a ....

[Article contains additional citation context not shown here]

Afek, Y., Dauber, D., and Touitou, D. Wait-free made fast. In Proceedings of the 27th Annual ACM Symposium on Theory of Computing (1995), pp. 538-- 547.

....on the new ideas of our algorithm, rather than on the difficulties of the extra synchronization necessary between LL SC pairs. Nevertheless, we discuss in Section 3. 3 how to replace the large RMW object associated with each location by an implementation that uses LL SC on single words (given in [ADT95]) and does not change the local contention and local step complexity properties of our algorithm. 1.2 The algorithm in a nutshell In this paper we present a wait free multi object algorithm on k objects, that has d local contention, and d local step complexity, for d = O(log n) We first ....

....algorithms neither avoid copying nor have disjoint access. Afek, Dauber, and Touitou present a wait free, universal translation method that avoids copying the entire data structure and in which the step complexity depends only on the (global) contention, but that does not allow disjoint access [ADT95]. In a later paper, Anderson and Moir present a waitfree methodology that avoids copying the data structure, but has Omega Gamma n) step complexity for even a single operation [AM95b] They also present a wait free multiword atomic implementation that allows disjoint access, but that gives rise ....

[Article contains additional citation context not shown here]

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proc. 27th ACM Symposium on Theory of Computing, pages 538--547, May 1995.

....in a constant number of steps. The fast lane in the road of distributed computing opened. Since then, much research has been directed to this quest, in generalizing the notion and finding instances of fast protocols, whether long lived, or single shot [AF98, CS93, BGHM95, MA94, Moi98, MA95, ADT95] A particular generalization of fast to contention sensitive, by which one means that the number of steps is proportional to the contention encountered, rather than the size of the system, has been the most promising. A break through in this direction was the introduction of network of ....

Yehuda Afek, Dalia Dauber, and Dan Touitou. Wait-free made fast. pages 538--547, 1995.

....range of names. Choy and Singh [21] present mutual exclusion algorithms, using read write operations, which are adaptive in an amortized sense; in the worst case, the step complexity of their algorithms depends on n. Alur and Taubenfeld [8] show that this is inherent. Afek, Dauber and Touitou [4] introduce general methods for adaptive implementations of long lived objects, using strong load linked and store conditional operations; the step complexity is linear in the number of processes that access the object concurrently. 2 Preliminaries In the shared memory model, processes p 1 ; ....

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proceedings of the 27th ACM Symposium on Theory of Computing, pages 538--547, 1995.

....in a range of size M . This paper considers only one shot renaming, a special case of the long lived M renaming problem [7] in which processes repeatedly acquire and release names from a range of 1 Moir and Anderson [22] use the term fast , which we avoid since it conflicts with other papers [3, 20]. 1 (Algorithm 7) O(k) union [19] O(k) Algorithm 3) 2k Gamma 1) renaming O(k 2 ) renaming [22] Algorithm 1) O(k log k) Algorithm 5) 6k Gamma 1) renaming O(k log k) O(n log n) Algorithm 4) 2k Gamma 1) renaming lattice agreement (Algorithm 2) O(N) Figure 1: The ....

....using only read write operations; the algorithms are adaptive only with respect to the amortized step complexity; in the worst case, their step complexity depends on n. Alur and Taubenfeld [6] show that this behavior is inherent for mutual exclusion algorithms. Afek, Dauber and Touitou [3] introduce universal methods for adaptive implementations of long lived objects. The step complexity of the implementations depends linearly on the actual number of processes that access the object concurrently; however, they require strong load linked and store conditional operations. 2 The ....

[Article contains additional citation context not shown here]

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proceedings of the 27th ACM Symposium on Theory of Computing, pages 538--547, 1995.

....identical programmes, and communicate via registers. They showed that (log n) shared registers and (log n) rounds are required for n processes to solve consensus. 9. 2 The Complexity of Universal Constructions Herlihy s universality result, discussed in Section 3, and subsequent similar papers [1, 33, 54, 73], provide universal constructions, which automatically give a distributed implementation of any object type, using suciently powerful sharedmemory primitives. Jayanti [67, 69] has studied some of the limitations of this approach to providing implementations. He showed that a process that performs ....

....processes have begun taking steps, and studying how information propagates through the system. Roughly speaking, each shared memory operation at most doubles the size of the the set of processes that are known (by some process or memory location) to have woken up. This lower bound is also tight [1]. 9.3 Lower Bounds on Time To understand the relative power of di erent models, it is important to obtain separation results by proving a lower bound for a problem in one model that is larger than its complexity in another model. One problem that has been used to obtain a separation result is ....

[Article contains additional citation context not shown here]

Yehuda Afek, Dalia Dauber, and Dan Touitou. Wait-free made fast. In Proc. 27th ACM Symposium on Theory of Computing, pages 538-547, 1995.

....[10, 1] is an important property for good performance. To achieve adaptiveness in our GRASP solution, we must use a wait free transaction implementation whose time complexity is a function of the number of active processes and of the amount of data accessed by the transaction. The construction of [2] has this property, but is not disjoint access parallel. 7 Concluding Remarks We have presented a very general synchronization problem and a solution to this problem. This work serves two purposes. First, it unifies many well known synchronization problems, and helps to clarify the relationships ....

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proceedings of the 27th Annual ACM Symposium on Theory of Computing, pages 538-- 547, 1995.

.... we are aware of that does not copy the entire object uses a complicated helping mechanism (which we think is unlikely to perform well in practice) to ensure worst case time complexity that depends on the number of processes accessing the object, rather than on the total number of processes [1]. The lock free and wait free constructions presented in [2] provide programmers with the illusion that their operations access objects that are stored in contiguous locations in memory. However, in reality, the object is fragmented into blocks, allowing the constructions to copy only blocks ....

Y. Afek, D. Dauber, and D. Touitou. Waitfree made fast. In Proceedings of the 27th Annual ACM Symposium on Theory of Computing, pages 538--547, 1995.

....participate in the algorithm. However, recently it has been observed that the worst case complexity of distributed algorithms could perhaps be made adaptive, that is, bounded by a function of a significantly smaller quantity, the number of concurrently participating, or actually active processes [4]. For example, Lamport s fast mutual exclusion algorithm [18] takes a constant number of steps if one processor runs alone and a linear in N number of steps if two or more processes run concurrently. Other adaptive (sometimes called fast) algorithms have been since designed [18, 4, 2, 19, 10, 6, ....

....active processes [4] For example, Lamport s fast mutual exclusion algorithm [18] takes a constant number of steps if one processor runs alone and a linear in N number of steps if two or more processes run concurrently. Other adaptive (sometimes called fast) algorithms have been since designed [18, 4, 2, 19, 10, 6, 9, 7]. Long lived and adaptive algorithms in the read write shared memory model have been previously presented only for the renaming problem [11, 2, 3] General methodologies for long lived adaptive algorithms have been presented only in a model that uses strong synchronization primitives such as ....

[Article contains additional citation context not shown here]

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proc. of the 27th Ann. ACM Symp. on Theory of Computing, pages 538--547, May 1995.

....these two code regions as well as statements 1. 2 and the test at statement 12 as wait free operations on a shared object consisting of the shared variables used in our algorithm. While this is a challenging problem to solve directly, there are a number of universal constructions (e.g. [1, 3, 17]) which can be used to implement such operations. Furthermore, universal constructions exist in which read only operations are implemented with only read operations (e.g. 3] Thus, if we use such a construction to implement our group mutual exclusion algorithm as described above, it would ....

Y. Afek, D. Dauber, and D. Touitou. Waitfree made fast. In Proceedings of the 27th Annual ACM Symposium on Theory of Computing, pages 538--547, 1995.

....making strong use of processor synchronization, and are not wait free. In [27] Herlihy also gave a general method for the construction of wait free objects [28] Unfortunately, the algorithm resulting from implementing a sorting object using this method (or the improvements of Afek et al. on it [1]) is inefficient. Processors wishing to update the shared object will have to first post the changes they are about to make. If they fail before these changes are completed another processor can complete them, ensuring the object remains consistent. This can be detrimental to parallelism as often ....

....first post the changes they are about to make. If they fail before these changes are completed another processor can complete them, ensuring the object remains consistent. This can be detrimental to parallelism as often only one process performs all pending work. For example, using the methods of [1], the complexity of a wait free operation is O(kf log f) where k is the number of processors accessing the object concurrently, and f is the complexity of the update operation. Using any straight forward sorting algorithm, we can expect k = P and O(PN log N ) cost per operation, which will not ....

[Article contains additional citation context not shown here]

Afek, Y., Dauber, D., and Touitou, D. Wait-free made fast (extended abstract). In Proceedings of the Twenty-Seventh Annual ACM Symposium on Theory of Computing (Las Vegas, Nevada, 29 May--1 June 1995), pp. 538--547.

....in the PRAM model, making strong use of processor synchronization, and are not wait free. In [17] Herlihy also gave a general method for the construction of wait free objects [18] Unfortunately, trying to implement a sorting object using this method (or the improvements of Afek et al. on it [1]) is liable to become inefficient. Processors wishing to update the shared object must first post the changes they are about to make. If they fail before these changes are completed another processor can complete them, ensuring the object remains consistent. This can be detrimental to parallelism ....

....first post the changes they are about to make. If they fail before these changes are completed another processor can complete them, ensuring the object remains consistent. This can be detrimental to parallelism as often only one process performs all pending work. For example, using the methods of [1], the complexity of a wait free operation is O(kf log f ) where k is the number of processors accessing the object concurrently, and f is the complexity of the update operation. Using any straight forward sorting algorithm, we can expect k = P , which will not yield good performance. Similar ....

[Article contains additional citation context not shown here]

Afek, Y., Dauber, D., and Touitou, D. Wait-free made fast (extended abstract). In Proceedings of the Twenty-Seventh Annual ACM Symposium on Theory of Computing (Las Vegas, Nevada, 29 May--1 June 1995), pp. 538--547.

....(in this case, the worst case expected shared access time complexity is#25 n) and (4) each process applies only one operation on the implemented object. Finally, the lower bound is tight: if the size of shared registers is not restricted, the universal construction of Afek, Dauber, and Touitou [1] (after two minor modifications) has O(log n) worst case shared access time complexity. An n process universal construction can be instantiated with the sequential specification of any type T to obtain a wait free implementation of an atomic object of type T that n concurrent processes can share. ....

....invokes an operation on the implementation and repeatedly takes steps, its operation will eventually complete, regardless of the speeds of other processes. Many recent wait free implementations are based on a shared memory that supports a pair of synchronization operations, known as LL and SC [33, 9, 19, 22, 1, 31, 4, 3, 7, 2, 30]. These operations work as follows. LL(a) returns the value at location a. SC(a, v) either changes the value at location a to v and returns true, or has no e#ect on location a and returns false. Correspondingly, we say the SC is successful or unsuccessful. Specifically, if process P applies ....

[Article contains additional citation context not shown here]

Afek, Y., Dauber, D., and Touitou, D. Wait-free made fast. In Proceedings of the 27th Annual ACM Symposium on Theory of Computing (1995), pp. 538-- 547.

....by implementing them as well as statements 1. 2 and the test at statement 12 as wait free operations on a shared object consisting of the shared variables used in our algorithm. While this is a challenging problem to solve directly, there are a number of universal constructions (e.g. [1, 3, 11, 17]) which can be used to implement such operations. Furthermore, universal constructions exist in which read only operations are implemented with only read operations (e.g. 3] Thus, if we use such a construction to implement our group mutual exclusion algorithm as described above, it would ....

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proceedings of the 27th Annual ACM Symposium on Theory of Computing, pp. 538--547, 1995.

.... Following Lamport s fast mutual exclusion algorithm [19] researchers have been designing adaptive algorithms, whose worst case step complexity is bounded by a function of the number of actually active or contending processes, rather than the total number of processes that might take steps [2]. For example, Lamport s fast mutual exclusion algorithm takes a constant number of steps if one processor runs alone and a linear in N number of steps if two or more processes run concurrently. Other adaptive (sometimes called fast) algorithms have been since designed [19, 2, 21, 10, 3, 9, 4] ....

....that might take steps [2] For example, Lamport s fast mutual exclusion algorithm takes a constant number of steps if one processor runs alone and a linear in N number of steps if two or more processes run concurrently. Other adaptive (sometimes called fast) algorithms have been since designed [19, 2, 21, 10, 3, 9, 4]. The strongest form of adaptiveness has been defined and achieved in a long lived renaming algorithm recently presented in [11, 1] In this algorithm the complexity of an operation is a function of the point contention of the operation, defined as the maximum number of processes executing ....

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proc. of the 23rd Ann. ACM Symp. on Theory of Computing, May 1995.

....identifiers. There are algorithms which enjoy adaptive step complexity: Choy and Singh [9] present mutual exclusion algorithms whose step complexity is adaptive when amortized across many entries to the critical section; however, these algorithms are not wait free. Afek, Dauber and Touitou [1] show wait free object implementations with adaptive step complexity; however, they employ load linked and store conditional operations, which are not available in many distributed environments and cannot be implemented from more basic read and write operations [11] Attiya and Fouren [3, 10] give ....

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proceedings of the 27th ACM Symposium on Theory of Computing, pages 538--547, 1995.

.... using a k exclusion and a k renaming algorithm is explored in [AM94] In this way a process that accesses the data structure alone has a O(k) complexity instead of O(n) A wait free, universal translation method in which the step complexity depends only on the (global) contention is presented in [ADT95]. This last method does not allow disjoint access. A wait free methodology that avoids copying the data structure, but has Omega Gamma n) step complexity for even a single operation is presented in [AM95b] A non blocking algorithm which implements 2 location atomic updates with helping and ....

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proc. 27th ACM Symposium on Theory of Computing, pages 538--547, May 1995.

....the mutual exclusion problem, using only read and write operations. Their algorithms are adaptive only with respect to the amortized step complexity; in the worst case, the step complexity of the algorithms may depend on n. In addition, their algorithms are not wait free. Afek, Dauber and Touitou [2] introduced universal methods for implementing adaptive long lived objects, whose step complexity depends linearly on the actual number of processes that access the object concurrently. However, their algorithms require strong load linked and store conditional operations. 1.1 Preliminaries ....

....as follows. This definition is equivalent to the definition given in [5] A process p i starts with V in (p i ) fp i g and is required to decide on a subset of the active processes, called a view, V out (p i ) such that the following 0 1 3 [0] 4] 7] 2 5 9 4 8 7 [1] [2] [3] 6] 5] 8] Figure 2: Numbering the blocks in the grid; the numbering of [12] appears in brackets. conditions hold: Comparability: for any i and j, either V out (p i ) V out (p j ) or V out (p j ) V out (p i ) and Self containment: for any i, V in (p i ) V out (p i ) The M ....

[Article contains additional citation context not shown here]

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proceedings of the 27th Annual Symposium on Theory of Computing, pages 538-- 547, 1995.

....N is large, while most of the time only a small number of processes take part in the computation. For such systems, step complexity which depends on N is undesirable: It is useful to have step complexity which adjusts to the number of processes taking part in the computation. An algorithm is fast [2, 16] if its step complexity depends only on the number of active processes, denoted k; k need not be fixed in advance and it may change in different executions of the algorithm. The step complexity of a fast algorithm adjusts to the degree of contention: It is constant if a single process executes the ....

....name in the range f0 : M Gamma 1g, for some M N . The smaller names produced by a renaming algorithm can replace processes original names, thus, making the step complexity depend only on the 1 Moir and Anderson [18] call these algorithms fast , conflicting with earlier terminology [2, 16]. number of active processes [3] This paper considers only one shot renaming, which is a special case of the long lived M renaming problem [3] in which processes repeatedly acquire and release names from the range f0; M Gamma 1g, for some M N . We present a fast algorithm for ....

[Article contains additional citation context not shown here]

Yehuda Afek, Dalia Dauber, and Dan Touitou. Wait-free made fast. In Proceedings of the 27th ACM Symposium on Theory of Computing, pages 538--547, 1995.

....and can therefore be implemented using static transactions. Israeli and Rappoport also presented lock free constructions for multi word synchronization primitives [7] these constructions employ the costly recursive helping policy discussed above. Most previous wait free universal constructions [1, 3, 6] implement only one object: in order to use them to implement multiple objects and to allow operations to access multiple objects atomically, the objects must be considered as a single object. None of these wait free constructions allow concurrent operations to execute in parallel. Thus, ....

....can execute in parallel. This is because the objects to be accessed by these multi object operations must be specified in advance; general implementations should not impose this restriction. Finally, efforts have been made to provide wait free constructions that avoid excessive copying overhead [1, 3], and that have time complexity that depends on contention, rather than on the number of processes [1, 4] 1 However, none of these constructions allow operations to execute in parallel. 2 3 Conditionally Wait Free MWCAS Implementation In this section we describe our conditionally wait free ....

[Article contains additional citation context not shown here]

Y. Afek, D. Dauber, and D. Touitou, "Wait-free Made Fast", Proceedings of the 27th Annual ACM Symposium on Theory of Computing, 1995.

No context found.

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proc. of the 27th Ann. ACM Symp. on Theory of Computing, pages 538--547, May 1995.

No context found.

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proc. of the 27th Ann. ACM Symp. on Theory of Computing, pages 538--547, May 1995.

.... exclusion [Lam87] researchers have asked whether distributed algorithms can be made adaptive; that is, can their worst case step complexity be bounded by a function of the number, k, of actually active or contending processes, rather than the total number of processes, N , that might take steps [ADT95] We also use n to denote an a priori known upper bound on k, which in the worst case is N . In [AF98] Attiya and Fouren provide several adaptive constructions for wait free collect, latticeagreement and renaming. Lattice agreement is a one shot version of atomic snapshot. It is a linearizable ....

Afek, Y., Dauber, D. and Touitou, D. Wait-free made fast, in Proc. 23rd Annual ACM Symp. on the Theory of Computing, 538-547, May 1995.

....Computer Science Department, Tel Aviv University, Israel 69978. stupp math.tau.ac.il IDC Herzliya, Israel 46150 dant idc.ac.il to enter the critical section all by itself does so in O(1) steps. Many efforts were invested since then in constructing adaptive implementations of shared objects [18, 25, 15, 14, 24, 2, 20, 11, 21, 22, 3, 6]. By adaptive we mean that the step complexity of an operation on the implemented task is only a function of the actual contention encountered by this operation, i.e. on the number of processors that actually take steps concurrently with that operation. While the renaming algorithms presented in ....

....actually take steps concurrently with that operation. While the renaming algorithms presented in [3] are indeed adaptive, each process may acquire a name only one time, i.e. these constructions are one shot. A process may not repeatedly acquire and release a name. The implementations presented in [2] are adaptive 1 , and long lived, i.e. a process may access the implementation any number of times. However, strong synchronization objects such as load linked and store conditional were used there, i.e. it is not in the read write shared memory model. Neither of the other references above is ....

[Article contains additional citation context not shown here]

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proc. of the 23rd Ann. ACM Symp. on Theory of Computing, May 1995.

No context found.

Yehuda Afek, Dalia Dauber, and Dan Touitou. Wait-free made fast. In Proceedings of the 27th ACM Symposium on Theory of Computing, pages 538--547, May 1995.

No context found.

Y. Afek, D. Dauber, and D. Touitou. Wait-free made fast. In Proceedings of the 27th ACM Symposium on Theory of Computing, pages 538--547, 1995.

No context found.

Yehuda Afek, Dalia Dauber, and Dan Touitou. Wait-free made fast. In Proceedings of the 27th ACM Symposium on Theory of Computing, pages 538--547, 1995.

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