Starvation Freedom Research Articles

Correctness Verification of Mutual Exclusion Algorithms by Model Checking

Mutual exclusion algorithms are at the heart of concurrent/parallel and distributed systems. It is well known that such algorithms are very difficult to analyze, and in the literature, different conjectures about starvation freedom and the number of by-passes (also called the overtaking factor) exist. The overtaking factor affects the (hopefully) bounded waiting time that a process competing for entering the critical section has to suffer before accessing the shared resource. This paper proposes a novel modeling approach based on Timed Automata and the Uppaal toolset, which proves effective for studying all the properties of a mutual exclusion algorithm for N≥2 processes, by exhaustive model checking. Although the approach, as already confirmed by similar experiments reported in the literature, is not scalable due to state explosion problems and can be practically applied until N≤5, it is of great value for revealing the true properties of analyzed algorithms. For dimensions N>5, the Statistical Model Checker of Uppaal can be used, which, although based on simulations, can confirm properties by estimations and probabilities. This paper describes the proposed modeling and verification method and applies it to several mutual exclusion algorithms, thus retrieving known properties but also showing new results about properties often studied by informal reasoning.

Achieving starvation-freedom in multi-version transactional memory systems

Software Transactional Memory systems (STMs) have garnered significant interest as an elegant alternative for addressing synchronization and concurrency issues with multi-threaded programming in multi-core systems. Client programs use STMs by issuing transactions. STM ensures that transaction either commits or aborts. A transaction aborted due to conflicts is typically re-issued with the expectation that it will complete successfully in a subsequent incarnation. However, many existing STMs fail to provide starvation freedom, i.e., in these systems, it is possible that concurrency conflicts may prevent an incarnated transaction from committing. To overcome this limitation, we systematically derive a novel starvation free algorithm for multi-version STM. Our algorithm can be used either with the case where the number of versions is unbounded and garbage collection is used or where only the latest K versions are maintained, KSFTM. We have demonstrated that our proposed algorithm performs better than existing state-of-the-art STMs.

Accelerating NoC Verification Using a Complete Model and Active Window

This work presents formal modeling of Network-on-Chip (NoC) considering detailed functional units of NoC. The intricate modeling of NoC router components like buffer, switch, and arbiter is accomplished using Finite State Machine (FSM). As in the case of a real NoC, parallel execution of these functional units is carried out by maintaining the synchronization between these functional units within a router and between each of the adjacent routers in the presented formal model. Important properties for the correctness of the proposed model are verified using a model checker. Implementing a detailed and a complete NoC model is a memory extensive operation while verifying with a model checker. We have introduced a concept of active windows to verify each router and its communication with the adjacent routers. The correctness of the model is checked by verifying the synchronization between NoC functional units and NoC routers, verifying progress in functional units, and verifying the successful transfer of packets. Verification of starvation freedom in an NoC router is also performed for round-robin arbiter and fixed-priority arbiter. Parallel threads are used in the experiments to reduce the verification time.

Fast Coflow Scheduling via Traffic Compression and Stage Pipelining in Datacenter Networks

Big data analytics in datacenters often involve scheduling of data-parallel jobs. Traditional scheduling techniques based on improving network resource utilization are subject to limited bandwidth in datacenter networks. To alleviate the shortage of bandwidth, some cluster frameworks employ techniques of traffic compression to reduce transmission consumption. However, they tackle scheduling in a coarse-grained manner at task level and do not perform well in terms of flow-level metrics due to high complexity. Fortunately, the abstraction of coflow pioneers a new perspective to facilitate scheduling efficiency. In this paper, we introduce a coflow compression mechanism to minimize the completion time in data-intensive applications. Due to the NP-hardness, we propose a heuristic algorithm called Fastest-Volume-Disposal-First (FVDF) to solve this problem. For online applicability, FVDF supports stage pipelining to accelerate scheduling and exploits recurrent neural networks (RNNs) to predict compression speed. Meanwhile, we build ${\sf Swallow}$ Swallow , an efficient scheduling system that implements our proposed algorithms. It minimizes coflow completion time (CCT) while guaranteeing resource conservation and starvation freedom. The results of both trace-driven simulations and real experiments show the superiority of our algorithm, over existing one. Specifically, ${\sf Swallow}$ Swallow speeds up CCT and job completion time (JCT) by up to $1.47 \times$ 1 . 47 × and $1.66 \times$ 1 . 66 × on average, respectively, over the SEBF in Varys, one of the most efficient coflow scheduling algorithms so far. Moreover, with coflow compression, ${\sf Swallow}$ Swallow reduces data traffic by up to 48.41 percent on average.

Efficient Data Center Flow Scheduling Without Starvation Using Expansion Ratio

Existing data center transport protocols are usually based on the Processor Sharing (PS) policy and/or the Shortest Remaining Processing Time (SRPT) policy. PS divides link bandwidth equally between competing flows, thus it fails to achieve optimal average flow completion time (FCT). SRPT prioritizes flows that have the shortest remaining processing time and provides near-optimal average FCT, but it may cause long flows to suffer unfair delays, or even starve them. In fact, these two types of policies represent two directions in the design space: PS prefers fairness (in terms of starvation freedom) while SRPT favors efficiency (in terms of average FCT). In this paper, we propose a novel metric, expansion ratio, which enables us to strike a balance between SRPT and PS. We design MERP that achieves efficient flow scheduling without starvation. MERP takes care of both average and tail FCTs by minimizing the expansion ratio of competing flows in a lexicographically manner. MERP controls the sending rate of competing flows via synchronized virtual deadlines and routes flows in a downstream-aware manner that reacts quickly to link failures. We evaluate MERP using extensive NS2-based simulations. Results show that, under various traffic loads, MERP reduces the tail FCT significantly with a negligible increase of average FCT compared with pFabric, and MERP reduces the average FCT notably compared with ECMP and CONGA when link failures occur.

Group mutual exclusion in linear time and space

We present two algorithms for the Group Mutual Exclusion (GME) Problem that satisfy the properties of Mutual Exclusion, Starvation Freedom, Bounded Exit, Concurrent Entry and First Come First Served. Both our algorithms use only simple read and write instructions, have O(N) Shared Space complexity and O(N) Remote Memory Reference (RMR) complexity in the Cache Coherency (CC) model. Our first algorithm is developed by generalizing the well-known Lamport's Bakery Algorithm for the classical mutual exclusion problem, while preserving its simplicity and elegance. However, it uses unbounded shared registers. Our second algorithm uses only bounded registers and is developed by generalizing Taubenfeld's Black and White Bakery Algorithm to solve the classical mutual exclusion problem using only bounded shared registers. We show that contrary to common perception our algorithms are the first to achieve these properties with this combination of complexities.

A Token-Based Solution to Group Local Mutual Exclusion Problem In Mobile Ad Hoc Networks

The article presents a generalization of the group mutual exclusion (GME) problem, called group local mutual exclusion (GLME), henceforth. In GLME, the activities of neighboring nodes need to be synchronized; however, no such synchronization is required between non-neighbors. The neighborhood is defined based on the location of the shared resources. A token-based solution to the GLME problem has also been proposed. The solution satisfies the correctness criteria for group mutual exclusion, i.e., safety, starvation freedom, and concurrent occupancy. The illustration includes simulation extensive results to estimate message overhead, latency, concurrency, and session switch complexity. The simulation results prove that the proposed algorithm demonstrates better performance when compared with the closest work in the literature. The token loss problem has also been handled. To the best of our knowledge, the algorithm presented in the paper is the first token-based algorithm to solve the GLME problem in MANETs.

Tidex

Several basic mutual exclusion lock algorithms are known, with one of the simplest being the Ticket Lock. We present a new mutual exclusion lock with properties similar to the Ticket Lock but using atomic_exchange() instead of atomic_fetch_add() that can be more efficient on systems without a native instruction for atomic_fetch_add(), or in which the native instruction for atomic_exchange() is faster than the one for atomic_fetch_add(). Similarly to the Ticket Lock, our lock has small memory foot print, is extremely simple, respects FIFO order, and provides starvation freedom in architectures that implement atomic_exchange() as a single instruction, like x86.

Efficient Coflow Scheduling Without Prior Knowledge

Inter-coflow scheduling improves application-level communication performance in data-parallel clusters. However, existing efficient schedulers require a priori coflow information and ignore cluster dynamics like pipelining, task failures, and speculative executions, which limit their applicability. Schedulers without prior knowledge compromise on performance to avoid head-of-line blocking. In this paper, we present Aalo that strikes a balance and efficiently schedules coflows without prior knowledge. Aalo employs Discretized Coflow-Aware Least-Attained Service (D-CLAS) to separate coflows into a small number of priority queues based on how much they have already sent across the cluster. By performing prioritization across queues and by scheduling coflows in the FIFO order within each queue, Aalo's non-clairvoyant scheduler reduces coflow completion times while guaranteeing starvation freedom. EC2 deployments and trace-driven simulations show that communication stages complete 1.93X faster on average and 3.59X faster at the 95th percentile using Aalo in comparison to per-flow mechanisms. Aalo's performance is comparable to that of solutions using prior knowledge, and Aalo outperforms them in presence of cluster dynamics.

Dynamic Request Set based Mutual Exclusion Algorithm in MANETs

Mutual Exclusion (ME) problem involves a group of processes, each of which intermittently requires access to the only resource present in the environment. Handling ME problem becomes difficult due to the dynamic nature of the ad hoc environment. This paper presents a token-based solution to ME problem in the mobile ad hoc environment. The proposed token based algorithm is sensitive to link forming and link breaking and thus is suitable for MANET. The algorithm uses the concept of dynamic request set (DRS). As the request set is dynamically updated, the average size of request set is reduced resulting in less number of messages exchanged per critical section. The algorithm satisfies mutual exclusion, starvation freedom, and freedom from deadlock. The present algorithm has been compared with DRS based ME algorithms for static distributed systems. The results show that the concept of DRS in MANETs can be successfully used. Token loss problem has also been handled separately in the present exposition.

Efficient coflow scheduling with Varys

Communication in data-parallel applications often involves a collection of parallel flows. Traditional techniques to optimize flow-level metrics do not perform well in optimizing such collections, because the network is largely agnostic to application-level requirements. The recently proposed coflow abstraction bridges this gap and creates new opportunities for network scheduling. In this paper, we address inter-coflow scheduling for two different objectives: decreasing communication time of data-intensive jobs and guaranteeing predictable communication time. We introduce the concurrent open shop scheduling with coupled resources problem, analyze its complexity, and propose effective heuristics to optimize either objective. We present Varys, a system that enables data-intensive frameworks to use coflows and the proposed algorithms while maintaining high network utilization and guaranteeing starvation freedom. EC2 deployments and trace-driven simulations show that communication stages complete up to 3.16X faster on average and up to 2X more coflows meet their deadlines using Varys in comparison to per-flow mechanisms. Moreover, Varys outperforms non-preemptive coflow schedulers by more than 5X.

An Improved k-Exclusion Algorithm

k-Exclusion is a generalization of Mutual Exclusion that allows up to k processes to be in the critical section concurrently. Starvation Freedom and First-In-First-Enabled (FIFE) are two desirable progress and fairness properties of k-Exclusion algorithms. We present the first known bounded-space k-Exclusion algorithm that uses only atomic reads and writes, satisfies Starvation Freedom, and has a bounded Remote Memory Reference (RMR) complexity. Our algorithm also satisfies FIFE, and has an RMR complexity of O(n) in both the cache-coherent and distributed shared memory models.

Complete assertional proof rules for progress under weak and strong fairness

The UNITY rules for leads-to, based on totality of the commands and weak fairness, are generalized to specifications with nontotal commands and impartiality. The rules and the corresponding predicate transformers are proved to be sound and complete by elementary means. These results are subsequently extended to specifications where the liveness property also contains a finite number of strong fairness assumptions. This is illustrated by means of a proof of starvation freedom for the standard implementation of mutual exclusion by plain semaphores, with strong fairness for the P operations.

Easy Formal Specification and Validation of Unbounded Networks-on-Chips Architectures

This article presents a formal specification and validation environment to prove safety and liveness properties of parametric -- unbounded -- NoCs architectures described at a high-level of abstraction. The environment improves the GeNoC approach with two new theorems, proving evacuation and starvation freedom. The application of the validation methodology is illustrated on a HERMES NoC with adaptive west-first routing and wormhole switching. This case study illustrates the strong compositional aspect of the GeNoC environment. The complete specification of this HERMES instance, together with the proof that the specification is deadlock-free, starvation free, and all messages eventually leave the network at their correct destination, could be achieved in about a week. Approximately 86% of this proof is automatically derived from the GeNoC model.

Hybrid Transactional Memory with Pessimistic Concurrency Control

Transactional Memory (TM) intends to simplify the design and implementation of the shared-memory data structures used in parallel software. Many Software TM systems are based on writer-locks to protect the data being modified. Such implementations can suffer from the “privatization” problem, in which transactional and non-transactional accesses to the same location can lead to inconsistent results. One solution is the use of Pessimistic Concurrency Control, but it entails an important performance penalty due to the need of reader-writer locking. In this paper a hybrid TM design is proposed to reduce the performance overheads caused by the use of these locks while combining three desirable features: (i) full TM functionality whether or not the architectural support is present; (ii) execution of a single common code path in software or hardware; and, (iii) immunity from the privatization problem. The analysis shows how a Hybrid TM can lose important properties, such as starvation freedom. To overcome this issue, Directory Reservations is presented, a low-cost mechanism improving existent solutions designed for Hardware TM.

Fairness and conspiracy concepts in concurrent systems

Many different fairness notions are available in literature. One should choose the proper definition that match with the system under consideration. In this paper we consider two known fairness definitions, viz., weak fairness and strong fairness. It is argued that these concepts are suitable for determining the degree of fairness of a given system. For only starvation freedom we require a minimum degree of fairness which we call least fairness. This idea is illustrated using two practical examples. Conspiracy is another very important issue in concurrent system. We have defined conspiracy in connection with all the fairness notions. Conspiracy resistant implementation is illustrated using a starvation free solution to dining philosophers problem. Dijkstra's weakest precondition calculus is used as the analytical tool.

A comprehensive strategy for contention management in software transactional memory

In Software Transactional Memory (STM), contention management refers to the mechanisms used to ensure forward progress--to avoid livelock and starvation, and to promote throughput and fairness. Unfortunately, most past approaches to contention management were designed for obstruction-free STM frameworks, and impose significant constant-time overheads. Priority-based approaches in particular typically require that reads be visible to all transactions, an expensive property that is not easy to support in most STM systems. In this paper we present a comprehensive strategy for contention management via fair resolution of conflicts in an STM with invisible reads. Our strategy depends on (1) lazy acquisition of ownership, (2) extendable timestamps, and (3) an efficient way to capture both priority and conflicts. We introduce two mechanisms--one using Bloom filters, the other using visible read bits --that implement point (3). These mechanisms unify the notions of conflict resolution, inevitability , and transaction retry . They are orthogonal to the rest of the contention management strategy, and could be used in a wide variety of hardware and software TM systems. Experimental evaluation demonstrates that the overhead of the mechanisms is low, particularly when conflicts are rare, and that our strategy as a whole provides good throughput and fairness, including livelock and starvation freedom, even for challenging workloads.

Parallelism-Aware Batch Scheduling: Enabling High-Performance and Fair Shared Memory Controllers

Uncontrolled interthread interference in main memory can destroy individual threads' memory-level parallelism, effectively serializing the memory requests of a thread whose latencies would otherwise have largely overlapped, thereby reducing single-thread performance. The parallelism-aware batch scheduler preserves each thread's memory-level parallelism, ensures fairness and starvation freedom, and supports system-level thread priorities.

Modeling fairness and starvation in concurrent systems

Standard temporal logic is augmented and a new temporal quantifier viz., never is defined. This augmented logic is integrated in Dijkstra's weakest precondition calculus. Definitions for fairness and starvation for concurrent systems in terms of weakest precondition are presented. According to the existing concept fairness for a transition rule asserts that if a rule remains continuously enabled (weak fairness) or repeatedly enabled (strong fairness), then it must be executed., where in the proposed definition fairness is related to the permission for execution where starvation relies upon actual execution. This definition is used to prove fairness of a given concurrent system. Through different examples it is shown that fairness is not the only prerequisite for starvation freedom. Available techniques use 'leads to' operator that forecasts system behavior where the proposed proof technique moves backward in time.

A note on Raymond's tree based algorithm for distributed mutual exclusion

The mutual exclusion problem is an important problem in distributed systems. The fairness property is a crucial attribute of distributed mutual exclusion algorithms. All solutions to the distributed mutual exclusion problem are expected to implement at least starvation freedom as the fairness criterion. In certain situations, a stronger fairness criterion is desirable. In this paper, we have substantially modified Raymond's tree based distributed mutual exclusion algorithm to incorporate such a fairness criterion, viz., the least executed criterion. The lower and upper bounds on the number of messages generated per critical section execution are 0 and 2 D respectively, where D is the diameter of a spanning tree of the distributed system. These bounds are the same as those of Raymond's algorithm.