Tight bounds for shared memory symmetric mutual exclusion problems

We consider the minimum number of variables required for symmetric mutual exclusion and related problems. The symmetric. mutual exclusion problem takes the standard shared memory mutual exclusion problem and adds the restriction that the the only way of distinguishing processes is by comparing identifiers, which are unique. This type of system is an analog of the anonymous ring 121. Truly anonymous shared memory systems cannot do anything useful.because of the impossibility of distinguishing identical processes [3], and asynchronous steps make it impossible to determine what a process is doing. Bounds for the number of shared variables for asymmetric mutual exclusion were known, but no lower bounds were known for symmetric lockout-free or deadlock free mutual exclusion. We prove that 2N1 variables are necessary and sufficient for any Iockoutfree symmetric. mutual exclusion algorithm. The lower bound holds even if comparisons between unequal identifiers can provide an arbitrary amount of information about identifiers. Also N variables are necessary and sufficient for deadlock free symmetric mutual exclusion. We prove that [log NJ + 1 variables are necessary and sufficient for symmetric leader election, even if asymmetric solutions are allowed. Other problems such as leader election with required participation and process numbering are also considered. Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific permission. @ 1989 ACM 0-89791-324-4/89/0008/0177 $1.50 1 Introducjion When mutual exclusion algorithms are discussed, it is usually assumed that the processes know their relative positions, so Ps knows it is the 5th process and can choose to write variable 11s accordingly. But in some cases, while each process has an identifier, but there are many more identifiers than processes, so identifiers cannot be easily used to index variables, or the structure of the identifiers may not allow indexing. For example, there may be millions of process identifiers but the number of processes, N, might be only in the hundreds. In this situation, a variable cannot be reserved for each identifier, because of the large number of variables required. Hashing or other techniques can rarely guarantee the unique number necessary for asymmetric protocols, assuming the original identifier is available in an appropriate form. Given this constraint on indexing, we want algorithms that can solve mutual exclusion type problems. We assume that identifiers can be written, read and compared for equality, but there is no way of looking inside any identifier. This gives the symmetric mutual erclusion problem. In the most restrictive case, it is assumed that the only operations allowed are copying identifiers and comparing for equality. The other extreme for symmetric systems might allow extraction of an arbitrary amount of information about identifiers from a comparison. Our model is the standard atomic read-write shared memory model. (No test-and-sets or similar operations allowed.) Our principle measure is the number of shared variables required to solve the given problem. In some cases, bounds on time and size of shared variables will