Dining Philosophers Problem Research Articles

Concurrent/Distributed programming illustrated using the dining philosophers problem

Many paradigms and techniques of distributed computing and concurrent processing have matured and are popular. A quick and effective way to assimilate the basics of these principles is to illustrat...

Quantitative program logic and expected time bounds in probabilistic distributed algorithms

In this paper we show how quantitative program logic (Morgan et al., ACM Trans. Programming Languages Systems 18 (1996) 325) provides a formal framework in which to promote standard techniques of program analysis to a context where probability and nondeterminism interact, a situation common to probabilistic distributed algorithms. We show that overall expected time can be formulated directly in the logic and that it can be derived from local properties of components. We illustrate the methods with an analysis of expected running time of the probabilistic dining philosophers (Lehmann and Ravin, Proc 8th Annu. ACM. Symp. on principles of Programming Languages, ACM, New York, 1981, p. 133).

Stabilization-Preserving Atomicity Refinement

Program refinements from an abstract to a concrete model empower designers to reason effectively in the abstract and architects to implement effectively in the concrete. For refinements to be useful, they must not only preserve functionality properties but also dependability properties. In this paper, we focus our attention on refinements that preserve the dependability property of stabilization. Specifically, we present a stabilization-preserving refinement of atomicity from an abstract model where a process can atomically access the state of all its neighbors and update its own state, to a concrete model where a process can only atomically access the state of any one of its neighbors or atomically update its own state. Our refinement is sound and complete with respect to the computations admitted by the abstract model, and induces linear step complexity and constant synchronization delay in the computations admitted by the concrete model. It is based on a bounded-space, stabilizing dining philosophers program in the concrete model. The program is readily extended to: (a) solve stabilization-preserving semantics refinement, (b) solve the stabilizing drinking philosophers problem, and (c) allow further refinement into a message-passing model.

Starving philosophers

Textbook discussions of synchronization seldom go beyond a brief introduction in terms of classical problems. This paper presents a simulator for the monitor solution of the dining philosophers problem that students can use to experimentally explore how such a solution might behave in practice. The simulator, which can be run remotely from a browser or can be downloaded for running locally, is written in Java so that it can be run on almost any system.

The fault span of crash failures

A crashing network protocol is an asynchronous protocol whose memory does not survive crashes. We show that a crashing network protocol that works over unreliable links can be driven to arbitrary global states, where each node is in a state reached in some (possibly different) execution, and each link has an arbitrary mixture of packets sent in (possibly different) executions. Our theorem considerably generalizes an earlier result, due to Fekete et al., which states that there is no correct crashing Data Link Protocol. For example, we prove that there is no correct crashing protocol for token passing and for many other resource allocation protocols such as k -exclusion, and the drinking and dining philosophers problems. We further characterize the reachable states caused by crash failures using reliable non-FIFO and reliable FIFO links. We show that with reliable non-FIFO links any acyclic subset of nodes and links can be driven to arbitrary states. We show that with reliable FIFO links, only nodes can be driven to arbitrary states. Overall, we show a strict hierarchy in terms of the set of states reachable by crash failures in the three link models.

Sharing Resources at Nonuniform Access Rates

We introduce DPPr (for ``Dining Philosophers Problem with rates'') as a generalization of the heavy-load case of the Dining Philosophers Problem (DPP). In DPPr, processes are required to be scheduled to access shared resources with prespecified relative frequencies. DPPr is an abstraction of resource-sharing problems to which the synchronization of some distributed algorithms for neural-network models and the generation of timing signals in asynchronous digital circuits are related. Two fully distributed, synchronous solutions are given for DPPr in this paper. The first solution employs a reduction to heavy-load DPP and after that a distributed scheduling mechanism that has been used to solve this problem with optimal concurrency. The second solution tackles the DPPr instance directly by operating on a multigraph based on that instance. We conclude by indicating how the two synchronous solutions carry over to the asynchronous case.

DESP‐C++: a discrete‐event simulation package for C++

DESP-C++ is a C++ discrete-event random simulation engine that has been designed to be fast, very easy to use and expand, and to be valid. DESP-C++ is based on the resource view. Its complete architecture is presented in detail, as well as a short ‘user manual’. The validity of DESP-C++ is demonstrated by the simulation of three significant models. In each case, the simulation results obtained with DESP-C++ match those obtained with a validated simulation software: QNAP2. The versatility of DESP-C++ is also illustrated this way, since the modelled systems are very different from each other: a simple production system, the dining philosophers' classical deadlock problem, and a complex object-oriented database management system. Copyright © 2000 John Wiley & Sons, Ltd.

A structured approach for developing concurrent programs in Java

In recent years, concurrent programming has become the norm rather than the exception in many applications. In particular, popularity of the Java programming language has accelerated this trend. Most textbooks on Operating Systems and concurrent programming teach concurrent programming by demonstrating solutions for some well-known problems, such as the producer/consumer, readers/writers, and dining philosophers problems. A more systematic and formal approach to develop concurrent programs is presented in [1, 2]. In this approach, for a given problem, we first specify a global invariant that implies the safety property. Then, we develop a so-called coarse-grained solution using the two synchronization constructs: and . Using Programming Logic, the global invariant is formally verified in the coarse-grained solution. Finally, the coarse-grained solution is mechanically translated to a fine-grained semaphore or monitor program that maintains the global invariant. This approach has many advantages. First, this is a formal approach that enables verification of programs being developed. Second, the most important activity in the programming process lies at a high level; namely, specifying global invariants. Once an appropriate global invariant is specified, much of the rest of the process is mechanical. Furthermore, global invariants and coarsegrained solutions are platform (synchronization primitive) independent. Thus, if the platform is switched from a semaphore-based to a monitor-based system, we only need to translate the existing coarse-grained solution to a monitor-based fine-grained program. The Java programming language encourages the use of multiple threads. Therefore, as Java’s popularity grows, concurrent programming using Java synchronization primitives will become more important. Java provides monitor-like synchronization primitives. However, these primitives have limitations. Each Java monitor object can only have one condition variable, which is associated with the object itself; all waits and signals (called notify in Java) refer to it. The translation

Colored cause-effect structures

We suggested the extension of the class of cause-effect structures by colored tokens. As an example of a colored cause-effect structure we use the well-known dining philosophers' problem. Relationships between the classes of colored cause-effect structures and colored Petri nets introduced by K. Jensen are investigated.

Coordination languages for parallel programming

A number of interesting models have been proposed and used to support coordination languages and systems. In this introductory paper, we first present a number of important concepts that form a context for classification and comparison of various coordination models and languages, and their applications. Next, we review three models and their associated languages, representing three different approaches to coordination. We illustrate the application of each model and language by using it to solve the classical dining philosophers problem. This paper ends with an overview of the rest of the papers that appear in this special issue.

Performance analysis of a constrained resource sharing system

We consider a queueing system where the servers are arranged in a circle, and each arriving customer requires a pair of resources that is shared by its server with the respective neighbors on either side. If either resource is being used, the customer is denied service. Customers arrive at each server according to independent Poisson processes, and lengths of service times at each server have an exponential distribution. We derive a closed-form formula for the expected fraction of busy servers at any time in terms of the number of servers and the utilization factor (defined as the arrival rate times the mean service-time duration). This allows us to evaluate system performance when these parameters are varied, and to determine whether denying service to arrivals at alternate servers improves performance. We relate the system to Dijkstra’s dining philosophers problem, which is an abstraction for resource sharing in an operating system.

Localizing failures in distributed synchronization

The fault-tolerance of distributed algorithms is investigated in asynchronous message passing systems with undetectable process failures. Two specific synchronization problems are considered, the dining philosophers problem and the binary committee coordination problem. The abstraction of a bounded doorway is introduced as a general mechanism for achieving individual progress and good failure locality. Using it as a building block, optimal fault-tolerant algorithms are constructed for the two problems.

The philosophers' process on ladder graphs

The Philosophers' Process is a Markovian version of the famous Dining Philosophers Problem introduced by Dijkstra as a model for resource sharing. It can be viewed as a reversible interacting particle system. This paper deals with the problem of computing its reversible measure in the case of a large but finite number of sites. This equilibrium measure is a Markov field on the underlying graph of interactions. When this graph has a linear structure (ladder graph), the reversible measure can be interpreted as the distribution of a stationary Markov chain. Its computation reduces to matrix products. This leads to explicit algorithms of computation in most cases of practical interest (grids, hypercubes, trees). Some examples of explicit formulae illustrate the results

What Can be Computed Locally?

The purpose of this paper is a study of computation that can be done in a distributed network, where locally means within time (or distance) independent of the size of the network. Locally checkable labeling (LCL) problems are considered, where the legality of a labeling can be checked (e.g., coloring). The results include the following: There are nontrivial LCL problems that have local algorithms. There is a variant of the dining philosophers problem that can be solved locally. Randomization cannot make an LCL problem local; i.e., if a problem has a local randomized algorithm then it has a local deterministic algorithm. It is undecidable, in general, whether a given LCL has a local algorithm. However, it is decidable whether a given LCL has an algorithm that operates in a given time $t$. Any LCL problem that has a local algorithm has one that is order-invariant (the algorithm depends only on the order of the processor IDs).

Algebraic high-level net transformation systems

The concept of algebraic high-level net transformation systems combines two important lines of research recently introduced in the literature:algebraic high-level nets(AHL-nets for short) andhigh-level replacement systems(HLR-systems for short). In both cases a categorical formulation of the corresponding theory has turned out to be highly important and is also a good basis for the integration of these concepts in this paper.AHL-nets combine Petri nets with algebraic specifications and provide a powerful specification technique for distributed systems including data types and processes.HLR-systems are transformation systems for high-level structures such as graphs, hypergraphs, algebraic specifications and different kinds of Petri nets. The theory of HLRsystems - formulated already in a categorical framework - is applied in this paper to AHLnets. Thus we obtain AHL-net transformation systems as an instantiation of HLR-systems to AHL-nets. This allows us to build up AHL-nets from basic components and to transform the net structure using rules or productions in the sense of graph grammars. This concept is illustrated by extending the well-known example of ‘dining philosophers’. We are able to show that AHL-net-transformation systems satisfy several important compatibility properties. On the one hand we obtain a local Church-Rosser and Parallelism Theorem, which is well-known for graph grammars and has recently been generalized to HLR-systems. This allows us to analyse concurrency in AHL-nets not only on the token level but also on the level of transformations of the net structure. On the other hand, we consider the ‘fusion’ and ‘union’ constructions for high-level structures, motivated by corresponding concepts for high-level Petri nets in the literature, and we show compatibility of these constructions with derivations of HLR-systems in general and AHL-nettransformations in particular. This means compatibility of vertical and horizontal structuring in terms of software development.

A methodology for monitor development in concurrent programs

Concurrent programming is one of the most difficult programming paradigms; in consequence, innovative methods and practical aids are necessary for a successful instruction. This paper presents a methodology for monitor development by joint use of stepwise refinement and monitor schemes. A monitor is developed in three stages, each one successively dealing with a different part of its specification, namely data abstraction specification, security properties and liveness/priority properties. Guidance is also obtained from some schemes for different parts of a monitor. The methodology is applied to two well known problems, the producer-consumer problem and the dining philosophers problem.

Fault-tolerant algorithms for fair interprocess synchronization

The implementation of nondeterministic pairwise synchronous communication among a set of asynchronous processes is modeled as the binary interaction problem. The paper describes an algorithm for this problem that satisfies a strong fairness property that guarantees freedom from process starvation. This is the first algorithm for binary interactions with strong fairness whose message cost and response time are independent of the total number of processes in the system. The paper also describes how the fair algorithm may be extended to tolerate detectable fail-stop failures. Finally, we show how any solution to the dining philosophers problem can be embedded to design a fair algorithm for binary interactions. In particular, this embedding is used to derive a fair algorithm that can cope with undetectable fail-stop failures.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

AN OPTIMAL ALGORITHM FOR THE DINING PHILOSOPHERS PROBLEM

We present a very simple new distributed algorithm for the classical Dining Philosophers problem. Our algorithm is the first algorithm with the following important properties: (1) It is fully distributed; i.e., there is no central memory or central process to which every other process may have access. (2) It is symmetric; i.e., all processes behave identically, and do not use any process identifiers. (3) It has a response time ≤ 3ℓ, independent of the size of the ring, where ℓ is an upper bound on the time a resource may be used by a process. Moreover, we establish the optimality of our algorithm with respect to this last measure by proving that no distributed algorithm can guarantee a response time less than 3ℓ.

An Ada solution to the general mutual exclusion problem

Although some specific mutual exclusion problems have been studied extensively, automatic solutions to synchronize general mutual exclusion problems with arbitrary mutual exclusion constraints have not been fully explored. This paper discusses an Ada 83 solution that can be applied to any general mutual exclusion problem. This solution is based on strong binary semaphores. A generic package is used to generate the solution for an given mutual exclusion problem. An Ada program for the simulation of the classical Dining Philosophers Problem is presented as an example to demostrate how the solution can be used.

Parallel program design using high‐level Petri nets

AbstractPetri nets are proposed as a general‐purpose design and modelling tool for parallel programs. The advantages of Petri nets for this purpose are discussed, and a solution to the Dining Philosophers problem is developed using simple Place‐Transition nets. The limitations of Place‐Transition nets are described, and the Dining Philosophers problem is used to illustrate how Coloured Petri nets can overcome these limitations. A more complex example of a Coloured Petri net is then given, and it is shown how a collection of processes in the Occam programming language can be developed directly from the properties of the net. Another Petri net model of a simple process farm is given, and a solution is developed in Parallel C: this further highlights the suitability of Petri nets as a design tool for parallel programs.