Comparing Mutual Exclusion Algorithms

U višedretvenom načinu rada sve dretve koje djeluju unutar istog procesa dijele sva sredstva koje je operacijski sustav stavio na raspolaganje tom procesu. Prilikom pristupa nekom zajedničkom resursu važno je sinkronizirati dretve na način da u svakom trenutku samo jedna dretva ima pravo pristupa. Mehanizmi međusobnoga isključivanja osiguravaju dretvama naizmjeničan pristup dijeljenom resursu. U radu su opisani i implementirani neki od najpoznatijih algoritamskih rješenja problema međusobnoga isključivanja. Najveći nedostatak ovakvih rješenja je radno čekanje. Dretve koje čekaju na ulazak u kritični odsječak će neprestano ispitivati varijablu dok ona ne promijeni svoju vrijednost čime se troši vrijeme i resursi procesora. Umjesto njih, postoje ugradbeni mehanizmi koji rješavaju problem radnog čekanja i značajno smanjuju iskorištenost procesora čime ubrzavaju izvođenje operacijskog sustava. U ovome radu sam opisao neke od razreda i knjižnica pomoću kojih se u programskom jeziku C++ može na jednostavan način kontrolirati pristup nekom dijeljenom resursu. Provedena je usporedba brzine rada algoritama i ugradbenih mehanizama ovisno o operacijskom sustavu na kojem se izvode

Comparing Mutual Exclusion Algorithms

U višedretvenom načinu rada sve dretve koje djeluju unutar istog procesa dijele sva sredstva koje je operacijski sustav stavio na raspolaganje tom procesu. Prilikom pristupa nekom zajedničkom resursu važno je sinkronizirati dretve na način da u svakom trenutku samo jedna dretva ima pravo pristupa. Mehanizmi međusobnoga isključivanja osiguravaju dretvama naizmjeničan pristup dijeljenom resursu. U radu su opisani i implementirani neki od najpoznatijih algoritamskih rješenja problema međusobnoga isključivanja. Najveći nedostatak ovakvih rješenja je radno čekanje. Dretve koje čekaju na ulazak u kritični odsječak će neprestano ispitivati varijablu dok ona ne promijeni svoju vrijednost čime se troši vrijeme i resursi procesora. Umjesto njih, postoje ugradbeni mehanizmi koji rješavaju problem radnog čekanja i značajno smanjuju iskorištenost procesora čime ubrzavaju izvođenje operacijskog sustava. U ovome radu sam opisao neke od razreda i knjižnica pomoću kojih se u programskom jeziku C++ može na jednostavan način kontrolirati pristup nekom dijeljenom resursu. Provedena je usporedba brzine rada algoritama i ugradbenih mehanizama ovisno o operacijskom sustavu na kojem se izvode

Efficient concurrent data structure access parallelism techniques for increasing scalability

Multi-core processors have revolutionised the way data structures are designed by bringing parallelism to mainstream computing. Key to exploiting hardware parallelism available in multi-core processors are concurrent data structures. However, some concurrent data structure abstractions are inherently sequential and incapable of harnessing the parallelism performance of multi-core processors. Designing and implementing concurrent data structures to harness hardware parallelism is challenging due to the requirement of correctness, efficiency and practicability under various application constraints. In this thesis, our research contribution is towards improving concurrent data structure access parallelism to increase data structure performance. We propose new design frameworks that improve access parallelism of already existing concurrent data structure designs. Also, we propose new concurrent data structure designs with significant performance improvements. To give an insight into the interplay between hardware and concurrent data structure access parallelism, we give a detailed analysis and model the performance scalability with varying parallelism.In the first part of the thesis, we focus on data structure semantic relaxation. By relaxing the semantics of a data structure, a bigger design space, that allows weaker synchronization and more useful parallelism, is unveiled. Investigating new data structure designs, capable of trading semantics for achieving better performance in a monotonic way, is a major challenge in the area. We algorithmically address this challenge in this part of the thesis. We present an efficient, lock-free, concurrent data structure design framework for out-of-order semantic relaxation. We introduce a new two-dimensional algorithmic design, that uses multiple instances of a given data structure to improve access parallelism. In the second part of the thesis, we propose an efficient priority queue that improves access parallelism by reducing the number of synchronization points for each operation. Priority queues are fundamental abstract data types, often used to manage limited resources in parallel systems. Typical proposed parallel priority queue implementations are based on heaps or skip lists. In recent literature, skip lists have been shown to be the most efficient design choice for implementing priority queues. Though numerous intricate implementations of skip list based queues have been proposed in the literature, their performance is constrained by the high number of global atomic updates per operation and the high memory consumption, which are proportional to the number of sub-lists in the queue. In this part of the thesis, we propose an alternative approach for designing lock-free linearizable priority queues, that significantly improve memory efficiency and throughput performance, by reducing the number of global atomic updates and memory consumption as compared to skip-list based queues. To achieve this, our new design combines two structures; a search tree and a linked list, forming what we call a Tree Search List Queue (TSLQueue). Subsequently, we analyse and introduce a model for lock-free concurrent data structure access parallelism. The major impediment to scaling concurrent data structures is memory contention when accessing shared data structure access points, leading to thread serialisation, and hindering parallelism. Aiming to address this challenge, a significant amount of work in the literature has proposed multi-access techniques that improve concurrent data structure parallelism. However, there is little work on analysing and modelling the execution behaviour of concurrent multi-access data structures especially in a shared memory setting. In this part of the thesis, we analyse and model the general execution behaviour of concurrent multi-access data structures in the shared memory setting. We study and analyse the behaviour of the two popular random access patterns: shared (Remote) and exclusive (Local) access, and the behaviour of the two most commonly used atomic primitives for designing lock-free data structures: Compare and Swap, and, Fetch and Add

A Study of Shared-Memory Mutual Exclusion Protocols using CADP

International audienceMutual exclusion protocols are an essential building block of concurrent systems: indeed, such a protocol is required whenever a shared resource has to be protected against concurrent non-atomic accesses. Hence, many variants of mutual exclusion protocols exist in the shared-memory setting, such as Peterson's or Dekker's well-known protocols. Although the functional correctness of these protocols has been studied extensively, relatively little attention has been paid to their nonfunctional aspects, such as their performance in the long run. In this paper, we report on experiments with the performance evaluation of mutual exclusion protocols using Interactive Markov Chains. Steady-state analysis provides an additional criterion for comparing protocols, which complements the verification of their functional properties. We also carefully re-examined the functional properties, whose accurate formulation as temporal logic formulas in the action-based setting turns out to be quite involved

Tournaments for mutual exclusion:verification and concurrent complexity

Given a mutual exclusion algorithm MXd for d≥2d≥2 threads, a mutual exclusion algorithm for N>dN>d threads can be built in a tree of degree d with N leaves, with the critical section at the root of the tree. This tournament solution seems obviously correct and efficient. The present note proves the correctness, and formalizes the efficiency in terms of concurrent complexity by means of Bounded Unity. If the tree is balanced, the throughput is logarithmic in N. If moreover MXd satisfies FCFS (first-come first-served), the worst case individual delay of the tournament algorithm is of order N. This is optimal

Group Mutual Exclusion in Linear Time and Space

The Group Mutual Exclusion (GME) problem, introduced by Joung, is a natural extension of the classical Mutual Exclusion problem. In the classical Mutual Exclusion problem, two or more processes are not simultaneously allowed to be in their CRITICAL SECTION, a piece of code where a common resource is accessed. In the GME problem, it is necessary to impose mutual exclusion on different groups in processes in accessing a resource, while allowing processes of the same group to share the resource. The Group Mutual Exclusion problem arises in several applications and is the focus of this thesis. We present an algorithm for the GME problem that satisfies the properties of Mutual Exclusion, Starvation Freedom, Bounded Exit, Concurrent Entry and First-Come-First Served. Our algorithm has [theta] (N) shared space complexity and [omicron] (N)RMR (Remote Memory Reference) complexity. Our algorithm is developed by generalizing the well-known Lamport's Bakery Algorithm for the classical mutual exclusion problem, while preserving its simplicity and elegance. Just like Lamport's Bakery Algorithm, our algorithm has the disadvantage that the token numbers can grow in an unbunded manner. When all shared variables are required to be of bounded size, Hadzilacos presented an algorithm, whose shared space complexity is [theta] (N²) and whose RMR complexity is claimed to be [omicron] (N). Hadzilacos posed as an open problem, the development of a linear time and space algorithm that uses only bounded shared variables and only simple read and write instructions. As a solution to the open problem, Jayanti et al. presented a space efficient adaptation of the above algorithm that uses only [theta] (N) shared space and inherited the claim that the RMR complexity is [omicron] (N) We show that both of these algorithms are of RMR complexity [omega] (N²) and thus demonstrate that both claims are erroneous. So, the open problem posed by Hadzilacos is still open.Open Access FundingM.S