Lamport defined three classes of communication registers: safe, regular, and atomic. Wait-free implementations of one register class from a weaker class abound in the literature. However, results establishing the intrinsic complexity of such implementations are relatively scarce. In this paper, we consider the problem of implementing an n -valued single reader, single writer atomic register A from two regular registers, BUF and R , where BUF is a regular register that only the writer of A can write and R is a regular register that only the reader of A can write. (Lamport proved that there cannot be an implementation without R , so R is at least 2-valued in any implementation.) We present an almost space optimal implementation. Specifically, our results are: (1) An implementation for which BUF is 2 n -valued and R is 2-valued; and (2) A lower bound stating that, in any implementation, regardless of how large R is, BUF must be at least (2 n −1)-valued.

No abstract available.

This paper presents a strong characterization that pre-

The computational power of concurrent data types has been the focus of much recent research. Herlihy showed that such power may be measured by the type’s ability to implement wait-free consensus. Jayanti argued that this ability could be measured in different ways, depending, for example, on whether or not read/write registers could be used in an implementation. He demonstrated the significance of this distinction by exhibiting a nondeterministic type whose ability to implement consensus was increased with the availability of registers. We show that registers cannot increase the ability to implement wait-free consensus of any deterministic type or of any type that can, without them, implement consensus for at least two processes. These results significantly impact the study of the wait-free hierarchies of concurrent data types. In particular, the combination of these results with other recent work suggests that Jayanti’s hm hierarchy is robust for certain classes of deterministic types.

The problem of election for asynchronous rings of processors is considered. Because of its many applications, this problem is important for both the practical and theoretical points of view. Thus, the availability of an algorithm that is good in both the average and the worst case has significant meaning. As an effort to achieve this goal, a new algorithm is designed and is simulated sequentially and analyzed by statistical methods. The statistical analysis demonstrates that the algorithm proposed is near optimal in the average case while its worst case message complexity is still O(n lg n). This is accomplished with the cost of one more bit in every message. This result is very interesting because it is contrary to the common belief that algorithms with good worst case complexity perform worse in the average case.>

In the difficult area of distributed algorithms, it is useful to find tools that have wide application.Here we consider a model in which communication is through asynchronous, atomic reads and writes of shared memory.One of our main results is a lemma showing that a single fail-stop failure can lead to ambiguity whenever a choice must be made.Thii lemma can be used to prove a variety of impossibility results and lower bounds.We use the lemma to give a simple proof of the optimality of our solution to the f-assignment problem.The L-assignment problem requires that a group of processors compete for a pool of distinct resources with the restriction that a limited number of processors can halt unexpectedly.(The problem differs from the normal &exclusion problem in that an explicit assignment of resources must be made.)Use of the lemma is also demonstrated by giving a simple proof for the lower bound of the pure buffers version of the concurrent reading while writing problem.Some other problems where the lemma applies are mentioned.

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

Article Improved algorithms for distributed resource allocation Share on Authors: Eugene Styer School of Information and Computer Science, Georgia Institute of Technology, Atlanta, Ga. School of Information and Computer Science, Georgia Institute of Technology, Atlanta, Ga.View Profile , Gary L. Peterson School of Information and Computer Science, Georgia Institute of Technology, Atlanta, Ga. School of Information and Computer Science, Georgia Institute of Technology, Atlanta, Ga.View Profile Authors Info & Claims PODC '88: Proceedings of the seventh annual ACM Symposium on Principles of distributed computingJanuary 1988 Pages 105–116https://doi.org/10.1145/62546.62567Published:01 January 1988 28citation515DownloadsMetricsTotal Citations28Total Downloads515Last 12 Months5Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access

An algorithm is given for the multi-writer version of the Concurrent Reading While Writing (CRWW) problem. The algorithm solves the problem of allowing simultaneous access to arbitrarily sized shared data without requiring waiting, and hence avoids mutual exclusion. This. demonstrates that a quite complicated concurrent control problem can be solved-without eliminating the efficiency of parallelism. One very important aspect of the algorithm are the tools developed to prove its correctness. Without these tools, proving the correctness of a solution to a problem of this complexity would be very difficult.

We present a simple, efficient protocol for constructing single-writer, multi-reader atomic shared values from singlewriter, multi-reader non-atomic (%egular") shared values.This solves the last open problem in the Concurrent Reading While Writing hierarchy.It is now known how to construct a multi-writer, multi-reader atomic shared value given only single-reader, single-writer non-atomic ("safe") shared bits.The protocol given here is remarkably simple and efficient.The total amount of shared space to communicate a shared value with a range of V to n readers is just O(n + log IV]) multi-reader regular bits, which is provably optimal (with very small constant factors).Similarly, the amount of communication (reading and writing of copies of the simulated shared values) required by readers and writers is also optimal.The simplicity of the protocol results in a short and easily understood proof of correctness.Great care has been taken to completely describe the protocol to avoid ambiguities.We also describe several variations of the protocol which optimize other goals.

We explore four classic problems in concurrent computing (election, mutual exclusion, consensus, and naming) when the number of processes which may participate is unbounded. Partial information about the number of processes actually participating and the concurrency level is shown to affect the computability and complexity of solving these problems when using only atomic registers. We survey and generalize work carried out in models with known bounds on the number of processes, and prove several new results. These include improved bounds for election when participation is required and a new adaptive starvation-free mutual exclusion algorithm for unbounded concurrency. We also survey results in models with shared objects stronger than atomic registers, such as test&set bits, semaphores or read–modify–write registers, and update them for the unbounded case.

While WritingThe problem of asynchronous processes reading shared data while the data are being modified by another process is considered.This problem differs from the standard readers/writers problem in that concurrent reading while writing is allowed.The model used here strongly limits the use and size of the shared variables.If multiple copies of the shared data are allowed, then simple, efficient solutions are found.In general, solutions which are more time efficient because they avoid waiting are seen to require more copies of the shared data.The number of copies used by all algorithms is shown to be the best possible.The main solution demonstrates that any system of processes which uses large distributed variables can be strongly simulated by a system which uses only binary distributed variables.

Concurrent Small SharedA new solution to the concurrent programming control (mutual exclusion) problem that is immune to process failures and restarts is presented.The algorithm uses just four values of shared memory per process, which is within one value of the known lower bound.The algorithm is implemented using two binary variables that make it immune to read errors occurring during writes, that is, "flickering bits."

An analysis is made of the shared memory requirements for implementing mutual excluslon of N asynchronous parallel processes m a model where the only primitive communication mechamsm is a general test-and-set operation on a single shared variable.While two variable values suffice to tmplement simple mutual exclusion without deadlock, it is shown that any solution whJch avoids possJble lockout of processes requires at least 2~ + ½ values A technical restnctmn on the model increases this requtrement to N/2 values, while achieving a fixed bound on wamng further increases the reqmrement to N + 1 values.These bounds are shown to be nearly optimal, for algorithms are exhibited for the last two cases which use [N/2J + 9 and N + 3 values, respectively All of the lower bounds apply afortiori to the space requirements for weaker primitives, such as P and V, using busy waiting Categones and Subject Descnptors D 4 1 [Operating Systems]" Process Management--mutual exclusion; D 4 2 [Operating Systems]' Storage Management F ! ![Computation by Abstract Devices]: Models of Computation, F !.2 [Computation by Abstract Devices]" Modes ofComputaUon--parallehsm, F 2 [Theory of Computation] Analysis of Algorithms and Problem Complexity General Terms Algonthms, Performance, Theory

A general paradigm for relating measures of succinctness of representation and complexity theory is presented. The measures are based on the new Private and Blindfold Alternation machines. These measures are used to indicate the inherent information (or "randomness") of a string, but with respect to time and space complexity classes. These measures are then used to show that the existence of strings which are random with respect to one measure but not to another can show the relationship between the corresponding complexity classes. The basic hierarchy theorems given allow different and possibly more powerful approaches to these problems.

A crucial property of distributed multiprocessing systems is the lack of complete information by any given process about the states of other processes. The contribution of this paper is a fundamental modal logic, MPL, for multiprocessing with incomplete information. (Section 1.5 gives an informal introduction to MPL; the formal definitions are in Section 2.)By way of this logic, we develop a solid (practical and theoretical) correspondence between distributed multiprocessing and multiplayer games of incomplete information.Fischer and Ladner, [1979] have shown a logspace reduction from the outcome problem for two person games of perfect information to satisfiability of formulas in their propositional dynamic logic (PDL). We provide in Section 3 a log-space reduction from the outcome problem for multiplayer games of incomplete information to satisfiability of formulas in our logic MPL. Although in general satisfiability in out logic is undecidable, the satisfiability problem of formulae with hierarchical visibility structure is shown decidable (using the methods for solving hierarchical games developed in Reif [1979] and Peterson and Reif [1979], and also the model theoretic techniques of Fischer and Ladner [1979] and Pratt [1979b]).At a more practical level, we argue that the game-like semantics of our logic provides a robust paradigm in which to view distributed multiprocessing problems. We apply our logic to describe total correctness properties of multi-process programs with shared variables as well as communicating processes with "handshake"-type message passing.

We generalize the alternation machines of Chandra, Kozen and Stockmeyer [1] and the private alternation machines of Reif [14] to model multiple person (team) games of incomplete information. The resulting classes of machines are "multiple person alternation machines". The characterization of certain time and space bounded versions of these machines demonstrate interesting relationships between ordinary time and space hierarchies (Table 1). Our results are applied to relative succintness and power questions of finite state machines and to complexity questions of parallel finite state machines. Other machine variants, including private alternating pushdown store automata and Markovian alternation machines, are discussed.

The question of relative efficiencies is studied in the context of a simple model of communicating aynchronous processes. The fundamental problem is whether a simple distributed system, with arbitrary size variables, is any more powerful than a system where only binary valued variables are permitted. The answer was (surprisingly) found to be negative, with an intuitive definition of the power of systems. The development of these notions required formalization of concepts such as equivalence of models, and the reduction of systems between models. It was discovered that requiring a strong definition of equivalence which decreased time apparently results in an increase in space. The trade-offs involved are seen to be tight in one approach to the problem.

A solution to the critical section problem, first posed by Dijkstra [1], is a fundamental requirement for concurrent program control. The problem is to ensure that no two processes are in a specified area of their programs (the critical section) at the same time. Improvements to Dijkstra's solution were made by Knuth [2], deBruijn [3], and Eisenberg and McGuire [4]. The situation, for a distributed system was considered by Lamport [5]. Rivest and Pratt [6] presented a solution for a distributed system where processes may repeatedly fail. The algorithms to be presented will be further improvements, where the comparisons will be made according to three measures: message size—the number of values the variable for interprocess communication can take on; fairness—the sequence in which waiting processes enter their critical sections; and time—the amount of time a process spends attempting to enter its critical section.