33,671 research outputs found
Contention-Free Complexity of Shared Memory Algorithms
AbstractWorst-case time complexity is a measure of the maximum time needed to solve a problem over all runs. Contention-free time complexity indicates the maximum time needed when a process executes by itself, without competition from other processes. Since contention is rare in well-designed systems, it is important to design algorithms which perform well in the absence of contention. We study the contention-free time complexity of shared memory algorithms using two measures: step complexity, which counts the number of accesses to shared registers; and register complexity, which measures the number of different registers accessed. Depending on the system architecture, one of the two measures more accurately reflects the elapsed time. We provide lower and upper bounds for the contention-free step and register complexity of solving the mutual exclusion problem as a function of the number of processes and the size of the largest register that can be accessed in one atomic step. We also present bounds on the worst-case and contention-free step and register complexities of solving the naming problem. These bounds illustrate that the proposed complexity measures are useful in differentiating among the computational powers of different primitive
Dynamic sharing of a multiple access channel
In this paper we consider the mutual exclusion problem on a multiple access
channel. Mutual exclusion is one of the fundamental problems in distributed
computing. In the classic version of this problem, n processes perform a
concurrent program which occasionally triggers some of them to use shared
resources, such as memory, communication channel, device, etc. The goal is to
design a distributed algorithm to control entries and exits to/from the shared
resource in such a way that in any time there is at most one process accessing
it. We consider both the classic and a slightly weaker version of mutual
exclusion, called ep-mutual-exclusion, where for each period of a process
staying in the critical section the probability that there is some other
process in the critical section is at most ep. We show that there are channel
settings, where the classic mutual exclusion is not feasible even for
randomized algorithms, while ep-mutual-exclusion is. In more relaxed channel
settings, we prove an exponential gap between the makespan complexity of the
classic mutual exclusion problem and its weaker ep-exclusion version. We also
show how to guarantee fairness of mutual exclusion algorithms, i.e., that each
process that wants to enter the critical section will eventually succeed
Distributed match-making
In many distributed computing environments, processes are concurrently executed by nodes in a store- and-forward communication network. Distributed control issues as diverse as name server, mutual exclusion, and replicated data management involve making matches between such processes. We propose a formal problem called distributed match-making as the generic paradigm. Algorithms for distributed match-making are developed and the complexity is investigated in terms of messages and in terms of storage needed. Lower bounds on the complexity of distributed match-making are established. Optimal algorithms, or nearly optimal algorithms, are given for particular network topologies
Progressive Transactional Memory in Time and Space
Transactional memory (TM) allows concurrent processes to organize sequences
of operations on shared \emph{data items} into atomic transactions. A
transaction may commit, in which case it appears to have executed sequentially
or it may \emph{abort}, in which case no data item is updated.
The TM programming paradigm emerged as an alternative to conventional
fine-grained locking techniques, offering ease of programming and
compositionality. Though typically themselves implemented using locks, TMs hide
the inherent issues of lock-based synchronization behind a nice transactional
programming interface.
In this paper, we explore inherent time and space complexity of lock-based
TMs, with a focus of the most popular class of \emph{progressive} lock-based
TMs. We derive that a progressive TM might enforce a read-only transaction to
perform a quadratic (in the number of the data items it reads) number of steps
and access a linear number of distinct memory locations, closing the question
of inherent cost of \emph{read validation} in TMs. We then show that the total
number of \emph{remote memory references} (RMRs) that take place in an
execution of a progressive TM in which concurrent processes perform
transactions on a single data item might reach , which
appears to be the first RMR complexity lower bound for transactional memory.Comment: Model of Transactional Memory identical with arXiv:1407.6876,
arXiv:1502.0272
Randomized versus Deterministic Implementations of Concurrent Data Structures
One of the key trends in computing over the past two decades has been increased distribution, both at the processor level, where multi-core architectures are now the norm, and at the system level, where many key services are currently distributed overmultiple machines. Thus, understanding the power and limitations of computing in a concurrent, distributed setting is one of the major challenges in Computer Science. In this thesis, we analyze the complexity of implementing concurrent data structures in asynchronous shared memory systems. We focus on the complexity of a classic distributed coordination task called renaming, in which a set of processes need to pick distinct names from a small set of identifiers. We present the first tight bounds for the time complexity of this problem, both for deterministic and randomized implementations, solving a long-standing open problem in the field. For deterministic algorithms, we prove a tight linear lower bound; for randomized solutions, we provide logarithmic upper and lower bounds on time complexity. Together, these results show an exponential separation between deterministic and randomized renaming solutions. Importantly, the lower bounds extend to implementations of practical shared-memory data structures, such as queues, stacks, and counters. From a technical perspective, this thesis highlights new connections between the distributed renaming problem and other fundamental objects, such as sorting networks, mutual exclusion, and counters. In particular, we show that sorting networks can be used to obtain optimal randomized solutions to renaming, and that, in turn, the existence of these solutions implies a linear lower bound on the complexity of the problem. In sum, the results in this thesis suggest that deterministic implementations of shared-memory data structures do not scale well in terms of worst-case time complexity. On the positive side, we emphasize randomization as a natural alternative, which can circumvent the deterministic lower bounds with high probability. Thus, a promising direction for future work is to extend our randomized renaming techniques to obtain efficient implementations of concurrent data structures
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
these combination of complexities.Comment: A total of 21 pages including 5 figures and 3 appendices. The bounded
shared registers algorithm in the old version has a subtle error (that has no
easy fix) necessitating replacement. A correct, but fundamentally different,
bounded shared registers algorithm, which has the same properties claimed in
the old version is presented in this new version. Also, this version has an
additional autho
- …