A dynamic information-structure mutual exclusion algorithm for distributed systems

A mutual exclusion (ME) algorithm consists of a trying protocol (TP)and exit protocol (EP)that surround a critical section (CS)and satisfy the following properties: mutual exclusion : at most one process is allowed to use the CS at a given time; lockout freedom : any process that enters the TP eventually enters the CS; and bounded exit : a process can complete the EP in a bounded number of its own steps. A First-Come-First-Served (FCFS) ME algorithm [1] additionally requires processes to enter the CS in roughly the order in which they start the TP. Once a process has started executing the TP of a ME algorithm, it has committed itself to entering the CS, since the correctness of the algorithm may depend on every process properly completing its TP and EP.

The authors present a dynamic token-based mutual exclusion algorithm for distributed systems. In the algorithm, a site invoking mutual exclusion sends token request messages to a set of sites possibly holding the token as opposed to all the sites as in the algorithm proposed by I. Suzuki and T. Kasami (1985). A request set is used to record the identifiers of such a set of sites in the system. The algorithm is dynamic because the request set is dynamically changed as the algorithm is executed. As the size of the request set is reduced, the number of the messages exchanged per critical section (CS) execution is reduced. Compared with Suzuki and Kasami's algorithm, the proposed algorithm can reduce the number of the messages exchanged by 40% when the traffic is light. Finally, the authors discuss relationship between the token-based and non-token-based mutual exclusion algorithms. This relationship motivated the authors to design such a dynamic token-based algorithm. >

Mutual exclusion is one of the most commonly used techniques to handle contention in concurrent systems. Traditionally, mutual exclusion algorithms have been designed under the assumption that a process does not fail while acquiring/releasing a lock or while executing its critical section. However, failures do occur in real life, potentially leaving the lock in an inconsistent state. This gives rise to the problem of recoverable mutual exclusion (RME) , which involves designing a mutual exclusion (ME) algorithm that can tolerate failures while maintaining required safety and liveness properties. In this work, we present a framework that transforms any algorithm that solves the RME problem into an algorithm that can also simultaneously adapt to (i) the number of processes concurrently competing for the lock, as well as (ii) the number of unresolved failures in the system, while maintaining the correctness properties and performance characteristics of the underlying RME algorithm. Additionally, the algorithm constructed as a result of this transformation adds certain desirable properties such as bounded recovery and fairness. One of the important performance measures of any ME algorithm, including an RME algorithm, is the number of remote memory references (RMRs) made by a process—to acquire and release a lock, as well as to recover the lock structure after a failure. Let R(n) denote the RMR complexity of a critical section request in the underlying RME algorithm, where n denotes the number of processes in the system. Then, our framework yields an RME algorithm for which the RMR complexity of a critical section request is given by \(\mathcal {O}(\min \lbrace \ddot{c},\sqrt {F+1},\ R(n) \rbrace)\) , where \(\ddot{c}\) denotes the point contention of the request and F denotes the failure-density of the request. We further extend our framework by presenting a novel memory reclamation algorithm to bound the space complexity of the RME algorithm. Our memory reclamation algorithm maintains the correctness, performance, and fairness properties of our transformation. Our approach is general enough that it may also be used to bound the space complexity of other RME algorithms. In addition to read and write instructions, our algorithm uses compare-and-swap ( CAS ) and fetch-and-store ( FAS ) hardware instructions, both of which are commonly available in most modern processors.

An efficient routing algorithm called hierarchical routing is presented in this paper. The algorithm assumes that the network is divided into logical clusters. In each cluster a so-called central controller stores the routing information and exchanges it with its neighboring central controllers. Each routing entry contains a time index which is used to react to dynamic topology changes and to minimize the amount of exchanged routing information. The presented algorithm is best suited for mobile ad hoc networks. The algorithm has been especially designed for a centralized ad hoc network HEE based on the HIPERLAN/2 standard standardized by ETSI but may be used in any ad hoc network configuration. The performance of the algorithm is analytically compared to the performance of the dynamic source routing algorithm.

We test four fast mean-field-type algorithms on Hopfield networks as an inverse Ising problem. The equilibrium behavior of Hopfield networks is simulated through Glauber dynamics. In the low-temperature regime, the simulated annealing technique is adopted. Although performances of these network reconstruction algorithms on the simulated network of spiking neurons are extensively studied recently, the analysis of Hopfield networks is lacking so far. For the Hopfield network, we found that, in the retrieval phase favored when the network wants to memory one of stored patterns, all the reconstruction algorithms fail to extract interactions within a desired accuracy, and the same failure occurs in the spin-glass phase where spurious minima show up, while in the paramagnetic phase, albeit unfavored during the retrieval dynamics, the algorithms work well to reconstruct the network itself. This implies that, as an inverse problem, the paramagnetic phase is conversely useful for reconstructing the network while the retrieval phase loses all the information about interactions in the network except for the case where only one pattern is stored. The performances of algorithms are studied with respect to the system size, memory load, and temperature; sample-to-sample fluctuations are also considered.

A hybrid TLBO-TS algorithm for integrated selection and scheduling of projects

In this paper, we present and evaluate dynamic dictionary-based estimation methods for joint model order and parameter estimation. In dictionary-based estimation, a continuous parameter space is discretized, and vector-valued dictionary elements are formed for specific parameter values. A linear combination of a subset of dictionary elements is used to represent the model, where the number of elements used is the estimated model order, and the parameters corresponding to the selected elements are the parameter estimates. In static-based methods, the dictionary is fixed; while in the dynamic methods proposed here, the parameter sampling, and hence the dictionary, adapt to the data. We propose two dynamic dictionary-based estimation algorithms in which the dictionary elements are dynamically adjusted to improve parameter estimation performance. We examine the performance of both static and dynamic algorithms in terms of probability of correct model order selection and the root mean-squared error of parameter estimates. We show that dynamic dictionary methods overcome the problem of estimation bias induced by quantization effects in static dictionary-based estimation, and we demonstrate that dictionary-based estimation methods are capable of parameter estimation performance comparable to the Cramér-Rao lower bound and to traditional ML-based model estimation over a wide range of signal-to-noise ratios.

Data replication is a known redundancy used in fault-tolerant distributed system. However, it has the problem of mutual exclusion of replicated data. Mutual exclusion becomes difficult when a distributed system is partitioned into two or more isolated groups of sites. In this study, a new dynamic algorithm is presented as a solution for mutual exclusion in partitioned distributed systems. The correctness of the algorithm is proven, and simulation is utilized for availability analysis. Simulations show that the new algorithm, ancestral dynamic voting algorithm, improves the availability and lifetime of service in faulty environments, regardless of the number of sites and topology of the system. This algorithm also prolongs the lifetime of service to mutual exclusion for full and partial topologies especially for the situations where there is no majority. Furthermore, it needs less number of messages transmitted. Finally, it is simple and easy to implement.

On-demand peer-to-peer ridesharing services provide flexible mobility options and are expected to alleviate congestion by sharing empty car seats. An efficient matching algorithm is essential to the success of a ridesharing system. The matching problem is related to the well-known dial-a-ride problem, which also tries to find the optimal pickup and delivery sequence for a given set of passengers. In this paper, we propose an efficient dynamic tree algorithm to solve the on-demand peer-to-peer ridesharing matching problem. The dynamic tree algorithm benefits from given ridesharing driver schedules and provides satisfactory runtime performances. In addition, an efficient pre-processing procedure to select candidate passenger requests is proposed, which further improves the algorithm performance. Numerical experiments conducted in a small network show that the dynamic tree algorithm reaches the same objective function values of the exact algorithm, but with shorter runtimes. Furthermore, the proposed method is applied to a larger size problem. Results show that the spatial distribution of ridesharing participants influences the algorithm performance. Sensitivity analysis confirms that the most critical ridesharing matching constraints are the excess travel times. The network analysis suggests that small vehicle capacities do not guarantee overall vehicle-kilometer travel savings.

A mutual exclusion algorithm with optimally bounded bypasses

First-Come-First-Served (FCFS) mutual exclusion (ME) is the problem of ensuring that processes attempting to concurrently access a shared resource do so one by one, in a fair order. In this paper, we close the complexity gap between FCFS ME and ME in the asynchronous shared memory model where processes communicate using atomic reads and writes only, and do not fail. Our main result is the first known FCFS ME algorithm that makes O(log N) remote memory references (RMRs) per passage and uses only atomic reads and writes. Our algorithm is also adaptive to point contention. More precisely, the number of RMRs a process makes per passage in our algorithm is Θ(min(k, log N)), where k is the point contention. Our algorithm matches known RMR complexity lower bounds for the class of ME algorithms that use reads and writes only, and beats the RMR complexity of prior algorithms in this class that have the FCFS property.

In the current dynamic probabilistic algorithm, the retransmission probability (pt) has always been formulated as a linear/non-linear function of a single variable, namely, the number of first-hop neighbors (k), and therefore denoted as pt(k). The performance of the probabilistic algorithm has severely suffered in the presence of noise due to the reduction in the probability of reception (pc) of route request packets by receiving nodes. This chapter presents a detailed description of a new dynamic probabilistic algorithm in which pt is determined as a function of k and pc, and therefore, it is referred to as the Dynamic Noise-Dependent Probabilistic (DNDP) algorithm. The DNDP algorithm is implemented using the Mobile Ad Hoc Network (MANET) Simulator (MANSim), which is used to simulate a number of scenarios to evaluate and compare the performance of the algorithm with pure flooding and fixed and dynamic probabilistic algorithms. The simulation’s results demonstrated that the DNDP algorithm provides an excellent performance in various network conditions, where it almost maintains the same network reach-ability in noiseless and noisy environments, with the noisy environments inflicting an insignificant increase in the number of redundant retransmissions.

While symmetric mutual exclusion algorithms are easy to implement, message complexity per critical section (CS) access to such approaches in a distributed system is typically high. There exist works that handle this issue but to a limited extent. In this paper, we propose a new symmetric algorithm for mutual exclusion. The proposed approach is essentially a prioritized version of the well-known Ricart–Agrawala algorithm for mutual exclusion in distributed systems. The solution proposed uses one or more priority levels, such that different participating processes are placed at different priority levels depending on the initial priority of the processes. The proposed algorithm maintains safety, liveness, and fairness properties toward implementation in a distributed system.

Hypercube have been commercially available in the past few years to their high degree of connectivity, symmetry, and low degree of diameter. In this paper, we analyse the performance in number of messages on d-dimensional hypercube, for two groups of distributed algorithms for mutual exclusion, a permission-based mutual exclusion group, and a token-based mutual exclusion group.In the permission-based mutual exclusion algorithm, a node enters in the critical section only after receiving permission from all others nodes, this algorithm requires d2 d messages.In the token-based mutual exclusion algorithm, a node is allowed to access its critical section if and only if it holds the token. In this algorithm, there is a node, called root, which knows the last node to get the token among the current requesting nodes. When a node wants to enter critical section, it sends request message to the root, which in turn informs the last node that new node will get the token next, and updates its last node. As result, the requesting nodes form a distributed queue, each of which records only the element next to it, this algorithm requires 2d messages in the worst case.

We present tradeoffs between RMR complexity and memory word size for recoverable mutual exclusion (RME) algorithms using arbitrary synchronization primitives. Assuming that each memory location stores w bits, we show that n-process mutual exclusion has an RMR complexity of at least Ω (min{logw n, log n/log log n}) on the DSM and the CC model. For w = (log n)Ω(1), our lower bound asymptotically matches an upper bound by Katzan and Morrison [19], whose RME mutual exclusion algorithm employs w-bit fetch-and-add operations. Our lower bound is the first one that does not restrict the type of atomic operations that can be executed on a memory location.