162,497 research outputs found
Maintaining Acyclicity of Concurrent Graphs*
In this paper, we consider the problem of preserving acyclicity in a directed graph (for
shared memory architecture) that is concurrently being updated by threads adding/deleting
vertices and edges. To the best of our knowledge, no previous paper has presented a con-
current graph data structure. We implement the concurrent directed graph data-structure
as a concurrent adjacency list representation. We extend the lazy list implementation of
concurrent linked lists for maintaining concurrent adjacency lists. There exists a number of
graph applications which require the acyclic invariant in a directed graph. One such example
is Serialization Graph Testing Algorithm used in databases and transactional memory. We
present two concurrent algorithms for maintaining acyclicity in a concurrent graph: (i) Based
on obstruction-free snapshots (ii) Using wait-free reachability. We compare the performance
of these algorithms against the coarse-grained locking strategy, commonly used technique
for allowing concurrent updates. We present the speedup obtained by these algorithms over
sequential execution. As a future direction, we plan to extend this data structure for other
progress conditions
Lock-free Concurrent Data Structures
Concurrent data structures are the data sharing side of parallel programming.
Data structures give the means to the program to store data, but also provide
operations to the program to access and manipulate these data. These operations
are implemented through algorithms that have to be efficient. In the sequential
setting, data structures are crucially important for the performance of the
respective computation. In the parallel programming setting, their importance
becomes more crucial because of the increased use of data and resource sharing
for utilizing parallelism.
The first and main goal of this chapter is to provide a sufficient background
and intuition to help the interested reader to navigate in the complex research
area of lock-free data structures. The second goal is to offer the programmer
familiarity to the subject that will allow her to use truly concurrent methods.Comment: To appear in "Programming Multi-core and Many-core Computing
Systems", eds. S. Pllana and F. Xhafa, Wiley Series on Parallel and
Distributed Computin
Brief Announcement: Wait-Free Universality of Consensus in the Infinite Arrival Model
In classical asynchronous distributed systems composed of a fixed number n of processes where some proportion may fail by crashing, many objects do not have a wait-free linearizable implementation (e.g. stacks, queues, etc.). It has been proved that consensus is universal in such systems, which means that this system augmented with consensus objects allows to implement any object that has a sequential specification. In this paper, we consider a more general system model called infinite arrival model where infinitely many processes may arrive and leave or crash during a run. We prove that consensus is still universal in this more general model. For that, we propose a universal construction based on a weak log that can be implementated using consensus objects
- …