We present lock-free and wait-free universal constructions for implementing large shared objects. Most previous universal constructions require processes to copy the entire object state, which is impractical for large objects. Previous attempts to address this problem require programmers to explicitly fragment large objects into smaller, more manageable pieces, paying particular attention to how suchpieces are copied. In contrast, our constructions are designed to largely shield programmers from this fragmentation. Furthermore, for many objects, our constructions result in lower copying overhead than previous ones. Fragmentation is achieved in our constructions through the use of load-linked, store-conditional, and validate operations on a \large " multi-word shared variable. Before presenting our constructions, we showthat these operations can be e ciently implemented from similar one-word primitives. 1

Many recent wait-free implementations are based on a sharedmemory that supports a pair of synchronization operations, known as LL and SC. In this paper, we establish an intrinsic performance limitation of these operations: even the simple wakeup problem [16], which requires some process to detect that all n processes are up, cannot be solved unless some process performs#for n) shared-memory operations. Using this basic result, we derive a#230 n) lower bound on the worst-case shared-access time complexity of n-process implementations of several types of objects, including fetch&increment, fetch&multiply, fetch&and, queue, and stack. (The worst-case shared-access time complexity of an implementation is the number of shared-memory operations that a process performs, in the worst-case, in order to complete a single operation on the implementation.) Our lower bound is strong in several ways: it holds even if (1) shared-memory has an infinite number of words, each of unbounded size, (2) sh...