We present an algorithm for verifying that a model M with timing constraints satisfies a given temporal property T . The model M is given as a parallel composition of !-automata P i , where each automaton P i is constrained by bounds on delays. The property T is given as an !-automaton as well, and the verification problem is posed as a language inclusion question L(M ) ` L(T ). In constructing the composition M of the constrained automata P i , one needs to rule out the behaviors that are inconsistent with the delay bounds, and this step is (provably) computationally expensive. We propose an iterative solution which involves generating successive approximations M j to M , with containment L(M ) ` L(M j ) and monotone convergence L(M j ) ! L(M ) within a bounded number of steps. As the succession progresses, the approximations M j become more complex. At any step of the iteration one may get a proof or a counterexample to the original language inclusion question. The described algori...

* Exclusion: At most one process executes its critical section at any time.

In a shared-memory distributed system, n independent asynchronous processes communicate by reading and writing to shared memory. An algorithm is adaptive (to total contention) if its step complexity depends only on the actual number, k, of active processes in the execution; this number is unknown in advance and may change in different executions of the algorithm. Adaptive algorithms are inherently wait-free, providing fault-tolerance in the presence of an arbitrary number of crash failures and different processes' speed. A wait-free adaptive collect algorithm with O(k) step complexity is presented, together with its applications in wait-free adaptive algorithms for atomic snapshots, immediate snapshots and renaming. Keywords: contention-sensitive complexity, wait-free algorithms, asynchronous sharedmemory systems, read/write registers, atomic snapshots, immediate atomic snapshots, renaming. Work supported by the fund for the promotion of research in the Technion. y Department of Computer Science, The Technion, Haifa 32000, Israel. hagit@cs.technion.ac.il. z Department of Computer Science, The Technion, Haifa 32000, Israel. leonf@cs.technion.ac.il. x Computer Science Department, UCLA. eli@cs.ucla.edu. 1

) Srikanth Ramamurthy, Mark Moir, and James H. Anderson Department of Computer Science, University of North Carolina at Chapel Hill Abstract We show that, for a large class of hard real-time systems, any object with consensus number P in Herlihy's wait-free hierarchy is universal for any number of tasks executing on P processors. These results exploit characteristics of priority-based schedulers common to most hard real-time systems. An important special case of this result is that, for hard real-time applications on uniprocessors, reads and writes are universal. Thus, Herlihy's hierarchy collapses for such applications. 1 Introduction This paper is concerned with implementations of shared objects in hard real-time systems. A hard real-time system is comprised of a collection of tasks that execute on one or more processors. A task is a sequential program that may be invoked repeatedly in response to an external stimulus or timer. Each invocation of a task must complete execution by ...

We establish trade-offs between time complexity and write- and access-contention for solutions to the mutual exclusion problem. The write-contention (access-contention) of a concurrent program is the number of processes that may be simultaneously enabled to write (access by reading and/or writing) the same shared variable. Our notion of time complexity distinguishes between local and remote accesses of shared memory. We show that, for any N-process mutual exclusion algorithm, if write-contention is w, and if at most v remote variables can be accessed by a single atomic operation, then there exists an execution involving only one process in which that process executes\Omega\Gammaecu vw N) remote operations for entry into its critical section. We further show that, among these operations,\Omega\Gamma p log vw N) distinct remote variables are accessed. For algorithms with access-contention c, we show that the latter bound can be improved to \Omega\Gamma/51 vc N ). The last two of thes...

This paper addresses the properties and design of long-lived adaptive algorithms in the read/write shared memory model. In particular we present adaptive and long-lived algorithms that adapt to the point contention of an operation while using only a bounded amount of memory. We believe the techniques and building blocks developed here to be of further use in the design of adaptive and long-lived algorithms. We use the renaming problem as a test-case to demonstrate the new techniques and properties. Three new implementations of adaptive, wait-free, and long-lived renaming in the read/write shared memory model are presented. Unlike previous algorithms [1] the three algorithms require a bounded number of registers and adapt to the point contention of an operation. The two previous algorithms presented in [1] either adapt to the point contention or use a bounded size memory...

A major issue in designing and programing multiprocessors is the cost of synchronization. Traditionally, this area of research has focused on hardware primitives and their implementation. In recent years, however, several researchers have demonstrated that what were perceived as hardware problems could be solved in software using simple synchronization primitives as building blocks. The difficulties involved in designing synchronization primitives vary greatly with the nature of the underlying hardware. The earliest work in the area assumed that the most powerful atomic primitive was a read or a write [7,9]. For various reasons, we are not interested in such a restriction: to begin with, such an algorithm can never be bounded [1]. The inefficiency of these algorithms prompted development of more powerful hardware primitives.

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 (6k - 1)-renaming; the step complexity of both algorithms is O(k log k). An interesting component of the (6k - 1)-renaming algorithm is an O(N) algorithm for (2k - 1)-renaming; this improves on the best previously known (2k - 1)-renaming algorithm, which has O(Nnk) s...

Concurrent systems in which there is a known upper bound \Delta on memory access time are considered. Two prototypical synchronization problems, mutual exclusion and consensus, are studied and solutions that have constant (i.e. independent of \Delta and the total number of processes) time complexity in the absence of contention are presented. For mutual exclusion, in the absence of contention, a process needs only five accesses to the shared memory to enter its critical section, and in the presence of contention, the winning process may need to delay itself for 4 \Delta \Delta time units. For consensus, in absence of contention, a process decides after four accesses to the shared memory, and in the presence of contention, it may need to delay itself for \Delta time units. 1 Introduction The possibility and complexity of synchronization in a distributed environment depends heavily on timing assumptions. In the asynchronous model no timing assumptions are made about the relative speeds ...

We present a mutual exclusion algorithm that performs well both with and without contention, on machines with no atomic instructions other than read and write. The algorithm capitalizes on the ability of memory systems to read and write at both full- and half-word granularities. It depends on predictable processor execution rates, but requires no bound on the length of critical sections, performs only O(n) total references to shared memory when arbitrating among conflicting requests (rather than O(n ) in the general version of Lamport's fast mutual exclusion algorithm), and performs only 2 reads and 4 writes (a new lower bound) in the absence of contention. We provide a correctness proof.