This article introduces the sieve, a novel building block that allows to adapt to the number of simultaneously active processes (the point contention) during the execution of an operation. We present an implementation of the sieve in which each sieve operation requires O(k log k) steps, where k is the point contention during the operation.The sieve is the cornerstone of the first wait-free algorithms that adapt to point contention using only read and write operations. Specifically, we present efficient algorithms for long-lived renaming, timestamping and collecting information.

In a shared-memory system, n independent asynchronous processes, with distinct names in the range {0, ..., N -1}, communicate by reading and writing to shared registers. An algorithm is wait-free if a process completes its execution regardless of the behavior of other processes. This paper considers wait-free algorithms whose complexity adjusts to the level of contention in the system: An algorithm is adaptive (to total contention) if its step complexity depends only on the actual number of active processes, k ; this number is unknown in advance and may change in different executions of the algorithm. Adaptive algorithms are presented for two important decision problems, lattice agreement and (6 k -1)- renaming ; the step complexity of both algorithms is O ( k log k ). An interesting component of the (6 k -1)-renaming algorithm is an O ( N ) algorithm for (2 k -1)-renaming; this improves on the best previously known (2 k -1)-renaming algorithm, which has O ( Nnk ) step complexity.The efficient renaming algorithm can be modified into an O ( N ) implementation of atomic snapshots using dynamic single -writer multi-reader registers. The best known implementations of atomic snapshots have step complexity O ( N log N ) using static single -writer multi-reader registers, and O ( N ) using multi -writer multi-reader registers.