Results 1 
3 of
3
Time and space lower bounds for implementations using cas
 In DISC
, 2005
"... Abstract. This paper presents lower bounds on the time and spacecomplexity of implementations that use the k compareandswap (kCAS) synchronization primitives. We prove that the use of kCAS primitives cannot improve neither the time nor the spacecomplexity of implementations of widelyused con ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
Abstract. This paper presents lower bounds on the time and spacecomplexity of implementations that use the k compareandswap (kCAS) synchronization primitives. We prove that the use of kCAS primitives cannot improve neither the time nor the spacecomplexity of implementations of widelyused concurrent objects, such as counter, stack, queue, and collect. Surprisingly, the use of kCAS may even increase the space complexity required by such implementations. We prove that the worstcase average number of steps performed by processes for any nprocess implementation of a counter, stack or queue object is Ω(log k+1 n), even if the implementation can use jCAS for j ≤ k. This bound holds even if a kCAS operation is allowed to read the k values of the objects it accesses and return these values to the calling process. This bound is tight. We also consider more realistic nonreading kCAS primitives. An operation of a nonreading kCAS primitive is only allowed to return a success/failure indication. For implementations of the collect object that use such primitives, we prove that the worstcase average number of steps performed by processes is Ω(log 2 n), regardless of the value of k. This implies a round complexity lower bound of Ω(log 2 n) for such implementations. As there is an O(log 2 n) round complexity implementation of collect that uses only reads and writes, these results establish that nonreading kCAS is no stronger than read and write for collect implementation round complexity. We also prove that kCAS does not improve the space complexity of implementing many objects (including counter, stack, queue, and singlewriter snapshot). An implementation has to use at least n base objects even if kCAS is allowed, and if all operations (other than read) swap exactly k base objects, then the space complexity must be at least k · n. 1
Multithreading Strategies for Replicated Objects ⋆
"... Abstract. Replicating objects usually requires deterministic behaviour for maintaining a consistent state. Multithreading is a critical source of nondeterminism, completely unsupported in most faulttolerant middleware systems. Recent publications have defined deterministic scheduling algorithms th ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
Abstract. Replicating objects usually requires deterministic behaviour for maintaining a consistent state. Multithreading is a critical source of nondeterminism, completely unsupported in most faulttolerant middleware systems. Recent publications have defined deterministic scheduling algorithms that operate at the middleware level and allow multithreading for replicated objects. This approach avoids deadlocks, improves performance, and makes the development better resemble that of nonreplicated objects. This paper surveys those algorithms and analyses their differences. It also defines extensions to two efficient multithreading algorithms to support nested invocations and condition variables with timebounded wait operations similar to the Java synchronisation model. In addition, we provide an experimental evaluation and performance comparison of the algorithms, indicating the areas in which each algorithm performs best. We conclude that replication middleware should implement reconfigurable multithreading strategies, as there is no optimal onesizefitsall solution. 1
SoloValency and the Cost of Coordination
, 2007
"... This paper introduces solovalency, a variation on the valency proof technique originated by Fischer, Lynch, and Paterson. The new technique focuses on critical events that influence the responses of solo runs by individual operations, rather than on critical events that influence a protocol’s singl ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
This paper introduces solovalency, a variation on the valency proof technique originated by Fischer, Lynch, and Paterson. The new technique focuses on critical events that influence the responses of solo runs by individual operations, rather than on critical events that influence a protocol’s single decision value. It allows us to derive √ n lower bounds on the time to perform an operation for lockfree implementations of concurrent objects such as linearizable queues, stacks, sets, hash tables, counters, approximate agreement, and more. Time is measured as the number of distinct base objects accessed and the number of stalls caused by contention in accessing memory, incurred by a process as it performs a single operation. We introduce the influence level metric that quantifies the extent to which the response of a solo execution of one process can be changed by other processes. We then prove the existence of a relationship between the space complexity, latency, contention and influence level of all lockfree object implementations. Our results are broad in that they hold for implementations that may use any collection of readmodifywrite operations in addition to read and write, and in that they apply even if base objects have unbounded size. 1