17,118 research outputs found
A Unified approach to concurrent and parallel algorithms on balanced data structures
Concurrent and parallel algorithms are different. However, in the case of dictionaries, both kinds of algorithms share many
common points. We present a unified approach emphasizing these points. It is based on a careful analysis of the sequential
algorithm, extracting from it the more basic facts, encapsulated later on as local rules. We apply the method to the
insertion algorithms in AVL trees. All the concurrent and parallel insertion algorithms have two main phases. A
percolation phase, moving the keys to be inserted down, and a rebalancing phase. Finally, some other algorithms and
balanced structures are discussed.Postprint (published version
Transiently Consistent SDN Updates: Being Greedy is Hard
The software-defined networking paradigm introduces interesting opportunities
to operate networks in a more flexible, optimized, yet formally verifiable
manner. Despite the logically centralized control, however, a Software-Defined
Network (SDN) is still a distributed system, with inherent delays between the
switches and the controller. Especially the problem of changing network
configurations in a consistent manner, also known as the consistent network
update problem, has received much attention over the last years. In particular,
it has been shown that there exists an inherent tradeoff between update
consistency and speed. This paper revisits the problem of updating an SDN in a
transiently consistent, loop-free manner. First, we rigorously prove that
computing a maximum (greedy) loop-free network update is generally NP-hard;
this result has implications for the classic maximum acyclic subgraph problem
(the dual feedback arc set problem) as well. Second, we show that for special
problem instances, fast and good approximation algorithms exist
Parallel dictionaries with local rules on AVL and brother trees
We present a set of local rules to deal with dictionaries, having as a main advantage their possible scheduling in a highly
synchronized way to get parallel dictionaries on AVLs. Up to now trees used in massively parallel dictionaries needed to
have all the leaves at the same depth, such as 2--3 trees. Therefore, it was possible (in insertions and deletions) to
reconstruct the tree bottom-up in a very regular fashion, as a pipeline of plane waves moving up. On AVL trees the
situation looks different because leaves can have different depth, therefore any wave in a pipeline is highly irregular. To
solve this problem we define {\it virtual} plane waves allowing us to develop an EREW dictionary for keys with
processors and time . Later on we generalize the sePostprint (published version
The Lock-free -LSM Relaxed Priority Queue
Priority queues are data structures which store keys in an ordered fashion to
allow efficient access to the minimal (maximal) key. Priority queues are
essential for many applications, e.g., Dijkstra's single-source shortest path
algorithm, branch-and-bound algorithms, and prioritized schedulers.
Efficient multiprocessor computing requires implementations of basic data
structures that can be used concurrently and scale to large numbers of threads
and cores. Lock-free data structures promise superior scalability by avoiding
blocking synchronization primitives, but the \emph{delete-min} operation is an
inherent scalability bottleneck in concurrent priority queues. Recent work has
focused on alleviating this obstacle either by batching operations, or by
relaxing the requirements to the \emph{delete-min} operation.
We present a new, lock-free priority queue that relaxes the \emph{delete-min}
operation so that it is allowed to delete \emph{any} of the smallest
keys, where is a runtime configurable parameter. Additionally, the
behavior is identical to a non-relaxed priority queue for items added and
removed by the same thread. The priority queue is built from a logarithmic
number of sorted arrays in a way similar to log-structured merge-trees. We
experimentally compare our priority queue to recent state-of-the-art lock-free
priority queues, both with relaxed and non-relaxed semantics, showing high
performance and good scalability of our approach.Comment: Short version as ACM PPoPP'15 poste
Recommended from our members
Revisiting lagrange relaxation (LR) for processing large-scale mixed integer programming (MIP) problems
Lagrangean Relaxation has been successfully applied to process many well known
instances of NP-hard Mixed Integer Programming problems. In this paper we present
a Lagrangean Relaxation based generic solver for processing Mixed Integer
Programming problems. We choose the constraints, which are relaxed using a
constraint classification scheme. The tactical issue of updating the Lagrange
multiplier is addressed through sub-gradient optimisation; alternative rules for
updating their values are investigated. The Lagrangean relaxation provides a lower
bound to the original problem and the upper bound is calculated using a heuristic
technique. The bounds obtained by the Lagrangean Relaxation based generic solver
were used to warm-start the Branch and Bound algorithm; the performance of the
generic solver and the effect of the alternative control settings are reported for a wide
class of benchmark models. Finally, we present an alternative technique to calculate
the upper bound, using a genetic algorithm that benefits from the mathematical
structure of the constraints. The performance of the genetic algorithm is also
presented
DeltaTree: A Practical Locality-aware Concurrent Search Tree
As other fundamental programming abstractions in energy-efficient computing,
search trees are expected to support both high parallelism and data locality.
However, existing highly-concurrent search trees such as red-black trees and
AVL trees do not consider data locality while existing locality-aware search
trees such as those based on the van Emde Boas layout (vEB-based trees), poorly
support concurrent (update) operations.
This paper presents DeltaTree, a practical locality-aware concurrent search
tree that combines both locality-optimisation techniques from vEB-based trees
and concurrency-optimisation techniques from non-blocking highly-concurrent
search trees. DeltaTree is a -ary leaf-oriented tree of DeltaNodes in which
each DeltaNode is a size-fixed tree-container with the van Emde Boas layout.
The expected memory transfer costs of DeltaTree's Search, Insert, and Delete
operations are , where are the tree size and the unknown
memory block size in the ideal cache model, respectively. DeltaTree's Search
operation is wait-free, providing prioritised lanes for Search operations, the
dominant operation in search trees. Its Insert and {\em Delete} operations are
non-blocking to other Search, Insert, and Delete operations, but they may be
occasionally blocked by maintenance operations that are sometimes triggered to
keep DeltaTree in good shape. Our experimental evaluation using the latest
implementation of AVL, red-black, and speculation friendly trees from the
Synchrobench benchmark has shown that DeltaTree is up to 5 times faster than
all of the three concurrent search trees for searching operations and up to 1.6
times faster for update operations when the update contention is not too high
Non-blocking Priority Queue based on Skiplists with Relaxed Semantics
Priority queues are data structures that store information in an orderly fashion. They are of tremendous importance because they are an integral part of many applications, like Dijkstra’s shortest path algorithm, MST algorithms, priority schedulers, and so on.
Since priority queues by nature have high contention on the delete_min operation, the design of an efficient priority queue should involve an intelligent choice of the data structure as well as relaxation bounds on the data structure. Lock-free data structures provide higher scalability as well as progress guarantee than a lock-based data structure. That is another factor to be considered in the priority queue design.
We present a relaxed non-blocking priority queue based on skiplists. We address all the design issues mentioned above in our priority queue. Use of skiplists allows multiple threads to concurrently access different parts of the skiplist quickly, whereas relaxing the priority queue delete_min operation distributes contention over the skiplist instead of just at the front. Furthermore, a non-blocking implementation guarantees that the system will make progress even when some process fails.
Our priority queue is internally composed of several priority queues, one for each thread and one shared priority queue common to all threads. Each thread selects the best value from its local priority queue and the shared priority queue and returns the value. In case a thread is unable to delete an item, it tries to spy items from other threads\u27 local priority queues.
We experimentally and theoretically show the correctness of our data structure. We also compare the performance of our data structure with other variations like priority queues based on coarse-grained skiplists for both relaxed and non-relaxed semantics
An Efficient Representation for Filtrations of Simplicial Complexes
A filtration over a simplicial complex is an ordering of the simplices of
such that all prefixes in the ordering are subcomplexes of . Filtrations
are at the core of Persistent Homology, a major tool in Topological Data
Analysis. In order to represent the filtration of a simplicial complex, the
entire filtration can be appended to any data structure that explicitly stores
all the simplices of the complex such as the Hasse diagram or the recently
introduced Simplex Tree [Algorithmica '14]. However, with the popularity of
various computational methods that need to handle simplicial complexes, and
with the rapidly increasing size of the complexes, the task of finding a
compact data structure that can still support efficient queries is of great
interest.
In this paper, we propose a new data structure called the Critical Simplex
Diagram (CSD) which is a variant of the Simplex Array List (SAL) [Algorithmica
'17]. Our data structure allows one to store in a compact way the filtration of
a simplicial complex, and allows for the efficient implementation of a large
range of basic operations. Moreover, we prove that our data structure is
essentially optimal with respect to the requisite storage space. Finally, we
show that the CSD representation admits fast construction algorithms for Flag
complexes and relaxed Delaunay complexes.Comment: A preliminary version appeared in SODA 201
- …