N-process Algorithm Research Articles

Tight Bounds for Critical Sections in Processor Consistent Platforms

Most weak memory consistency models are incapable of supporting a solution to mutual exclusion using only read and write operations to shared variables. Processor consistency-Goodman's version (PC-G) is an exception. Ahamad et al. showed that Peterson's mutual exclusion algorithm is correct for PC-G, but Lamport's bakery algorithm is not. This paper derives a lower bound on the number of and type of (single or multiwriter) variables that a mutual exclusion algorithm must use in order to be correct for PC-G. Specifically, any such solution for n processes must use at least one multiwriter variable and n single-writer variables. Peterson's algorithm for two processes uses one multiwriter and two single-writer variables, and therefore establishes that this bound is tight for two processes. This paper presents a new n-process algorithm for mutual exclusion that is correct for PC-G and achieves the bound for any n. While Peterson's algorithm is fair, this extension to arbitrary n is not fair. Six known algorithms that use the same number and type of variables are shown to fail to guarantee mutual exclusion when the memory consistency model is only PC-G, as opposed to the sequential consistency model for which they were designed. A corollary of our investigation is that, in contrast to sequential consistency, multiwriter variables cannot be implemented from single-writer variables in a PC-G system

Analysis of Some Lockout Avoidance Algorithms for the k-Exclusion Problem

We analyze two algorithms for the k-exclusion problem on the asynchronous multi-writer/reader shared memory model and show their correctness. The first algorithm is a natural extension of the n-process algorithm by Peterson for the mutual exclusion algorithm to the k-exclusion problem, and the second algorithm is a combination of the first algorithm and the tournament algorithm by Peterson and Fischer for the mutual exclusion problem. These two algorithms satisfy k-exclusion, and can tolerate up to k-1 process failures of the stopping type. The running times by the first algorithm and by the second algorithm are bounded by (n-k)c+O(n(n-k)2)l and (n/k)kc+O((n/k)k+1k)l, respectively, even if there exist at most k-1 process failures of the stopping type, where n is the number of processes, l is an upper bound on the time between successive two atomic steps for any faultless process, and c is an upper bound on the time that any user spends in the critical region.

A new fast-path mechanism for mutual exclusion

Several years ago, Yang and Anderson presented all N-process algorithm for mutual exclusion under read/write atomicity that has Θ(log N) time complexity, where "time" is measured by counting remote memory references. In this algorithm, instances of a two-process mutual exclusion algorithm are embedded within a binary arbitration tree. In the two-process algorithm that was used, all busy-waiting is done by "local spinning." Performance studies presented by Yang and Anderson showed that their N-process algorithm exhibits scalable performance under heavy contention. One drawback of using an arbitration tree, however, is that each process is required to perform Θ(log N) remote memory operations even when there is no contention. To remedy this problem, Yang and Anderson presented a variant of their algorithm that includes a "fast-path" mechanism that allows the arbitration tree to be bypassed in the absence of contention. This algorithm has the desirable property that contention-free time complexity is O(1). Unfortunately, the fast-path mechanism that was used caused time complexity under contention to rise to Θ(N) in the worst case. To this day, the problem of designing a read/write mutual exclusion algorithm with O(1) time complexity in the absence of contention and O(log N) time complexity under contention has remained open. In this paper, we close this problem by presenting a fast-path mechanism that achieves these time complexity bounds when used in conjunction with Yang and Anderson's arbitration-tree algorithm.

SPEEDUP OF THE n-PROCESS MUTUAL EXCLUSION ALGORITHM

We propose two modifications of the n-process mutual exclusion algorithm by Peterson for the asynchronous multi-writer/reader shared memory model. By any of the modifications we can speed up the original n-process algorithm. The running times for the trying regions of the first modified algorithm and the second modified algorithm are (2n - 3)c + O(n3 l) and (n - 1)c + O(n3 l), respectively, where n is the number of processes, l is an upper bound on the time between two steps, and c is an upper bound on the time that any user spends in the critical region. These running times are improvements on the running time, O(n2c + n4 l) of the original n-process algorithm for the same asynchronous shared memory model.