A general technique for implementation of efficient priority queues

We consider the implementation of meldable priority queues with integer keys in the RAM model. We present two new general techniques for transforming non-meldable priority queues into meldable ones. These transformations can be described symbolically as:non-meldable priority queue +union-find ← meldable priority queuenon-meldable priority queue +slow meldable priority queue ←faster meldable priority queueUsing the first transformation to combine a recent non-meldable RAM priority queue of Thorup with the classical union-find data structure we obtain a meldable RAM priority queue with an amortized cost of O(log log n·α(n)) per operation, where α(n) = α(n, n) is the inverse Ackermann function. Using instead a randomized priority queue of Han and Thorup we obtain an expected amortized cost of O(√(log log n) · α(n)) per operation. The second transformation yields slower meldable priority queues, but the obtained queues can support the insert, find-min and decrease-key operations in constant time. In particular, by combining a randomized atomic-heap of Thorup with, e.g., the classical Fibonacci heaps of Fredman and Tarjan, we obtain, for every fixed e > 0, a meldable priority queue with an expected amortized cost of O(1) for each insert, find-min and decrease-key operation, and an expected amortized cost of O((log n)1/2+e) for each delete or meld operation.Using the meldable priority queues of the first type, we obtain improved algorithms for finding minimum directed spanning trees in graphs with integer edge weights: a deterministic O(m · log log n · α(n)) time algorithm and a randomized O(m · √(log log n) · α(n)) expected time algorithm. These bounds improve, for very sparse graphs, on the O(m + n log n) running time of an algorithm by Gabow, Galil, Spencer and Tarjan that works for arbitrary edge weights.

Fast and lock-free concurrent priority queues for multi-thread systems

We present a new data-structure for representing priority queues, the pagoda. A detailed analysis shows that the pagoda provides a very efficient implementation of priority queues, where our measure of efficiency is the average run time of the various algorithms. It handles an arbitrary sequence of n primitive operations chosen from MIN, INSERT, UNION, EXTRACT and EXTRACTMIN in time o(n log n). The constant factors affecting these asymptotic run time are small enough to make the pagoda competitive with any other priority queue, including structures which cannot handle UNION or EXTRACT. The given algorithms process an arbitrary sequence of n operations MIN, INSERT and EXTRACT in linear average time O(n), and a sequence of n INSERT in linear worst case time O(n).

This article presents the implementation of a priority queue with simulated parameterized components on the scenario of a banking institution in which four main elements were used: 1) the dispenser, 2) the cashier(s), 3) the server that receives and assigns the priority of the turns, and 4) a screen that displays the order of the turns. In any banking institution, there is always a large number of users that require attention, so they implement special turns to give priority to customers, improving the quality of service. One of the important elements within the cycle of service provision is related to the waiting lines, commonly called queues. Basically one queue is managed with the First-In, First-Out discipline. In this aspect, disciplines such as queuing theory help to understand the behavior of queues by examining all the components of the waiting lists. One of the most used disciplines for the management of a queue, is the enqueue with priority. In a priority queue, the element with the highest priority is removed before any other elements. The research was carried out using mainly a quantitative approach. The main goal of this type of research is the formulation and demonstration of theories and seeks that the studies carried out can be replicated. The algorithm implemented highly parameterizable allowed the correct simulation of a priority queue that can be taken as a basis for a subsequent application in any type of organization.

The weak-heap data structure: Variants and applications

The k-means method is a widely used technique for clustering points in Euclidean space. While it is extremely fast in practice, its worst-case running time is exponential in the number of data points. We prove that the k-means method can implicitly solve PSPACE-complete problems, providing a complexity-theoretic explanation for its worst-case running time. Our result parallels recent work on the complexity of the simplex method for linear programming.

Formal specification of software components, as a core research area in software engineering, has been widely studied in decades. Although quite a few formal models have been proposed for this purpose, specification of concrete software components is still a challenging task due to the complexity of the functionalities of the components. In this paper, we use the stream function model to specify the behavior of priority queue, a commonly used software component. This specification formally defines the regular behavior and fault tolerance behavior of priority queue. In particular, a priority-concatenation operator is defined to handle the ordering of data items to ensure the highest-priority item is removed first. A finite state machine as an implementation is built based on this specification. In addition, we also discuss a priority upgrading approach to handle possible starvation situation of low-priority data items in the priority queue.

We propose the design and an implementation of a bulk-parallel external memory priority queue to take advantage of both shared-memory parallelism and high external memory transfer speeds to parallel disks. To achieve higher performance by decoupling item insertions and extractions, we offer two parallelization interfaces: one using bulk sequences, the other by defining limit items. In the design, we discuss how to parallelize insertions using multiple heaps, and how to calculate a dynamic prediction sequence to prefetch blocks and apply parallel multiway merge for extraction. Our experimental results show that in the selected benchmarks the priority queue reaches 64% of the full parallel I/O bandwidth of SSDs and 49% of rotational disks, or the speed of sorting in external memory when bounded by computation.

Priority queues are among the most useful of all data structures. Existing priority queues have a vast amount of overhead associated with them. There is a need to have a simple data structure that can be used as a priority queue with low overhead. The data structure should have the operation where the data item with the minimum/maximum value is the next item to be deleted. The data structure should also support the function of a calendar queue where elements with the same or similar priority have the same key. For example, all of today’s appointments will have today’s date as their key. To that end, a bucket data structure has been developed that has both of these features. We address the functionality and efficiency of the data structure for the applications of adaptive multivariate integration and the 15-puzzle. In adaptive multivariate integration, the key is an error estimate, which is a floating-point number. The data for this application has many items with similar keys and the maximum is the next item to be deleted. The key for the 15-puzzle is generated by a heuristic cost function. The data for this application has many items with the same key and the minimum is the next item to be deleted. This paper presents an implementation of the bucket priority queue and discusses its performance.KeywordsPriority queueBucket data structureHeapPerformance

Reflected min-max heaps

Priority queues and double-ended priority queues are fundamental data types in Computer Science, and various data structures have been proposed to implement them. In particular, diamond deques, int ...

Over the past decade, a pair of instructions called load-linked (LL) and store-conditional (SC) have emerged as the most suitable synchronization instructions for the design of lock-free algorithms. However, current architectures do not support these instructions; instead, they support either CAS (e.g., UltraSPARC, Itanium) or restricted versions of LL/SC (e.g., POWER4, MIPS, Alpha). Thus, there is a gap between what algorithm designers want (namely, LL/SC) and what multiprocessors actually support (namely, CAS or RLL/RSC). To bridge this gap, a flurry of algorithms that implement LL/SC from CAS have appeared in the literature. The two most recent algorithms are due to Doherty, Herlihy, Luchangco, and Moir (2004) and Michael (2004). To implement M LL/SC objects shared by N processes, Doherty et al.'s algorithm uses only O(N + M) space, but is only non-blocking and not wait-free. Michael's algorithm, on the other hand, is wait-free, but uses O(N2 + M) space. The main drawback of his algorithm is the time complexity of the SC operation: although the expected amortized running time of SC is only O(1), the worst-case running time of SC is O(N2). The algorithm in this paper overcomes this drawback. Specifically, we design a wait-free algorithm that achieves a space complexity of O(N2 + M), while still maintaining the O(1) worst-case running time for LL and SC operations.

The Delaunay triangulation of n points in the plane can be constructed in o(n log n) time when the coordinates of the points are integers from a restricted range. However, algorithms that are known to achieve such running times had not been implemented so far. We explore ways to obtain a practical algorithm for Delaunay triangulations in the plane that runs in linear time for small integers. For this, we first implement and evaluate two variants of BrioDC, an algorithm that is known to achieve this bound. We implement the first O(n)-time algorithm for constructing Delaunay triangulations and found that our implementations are practical. While we do not improve upon fast existing algorithms (with non-optimal worst-case running time) for realistic data sets, our BrioDC implementations do give us insight into the optimal time needed for point location. Secondly, we implement and evaluate variants of BRIO, an algorithm which has an O(n log n) worst-case running time on small integers but runs faster for many distributions. Our variants aim to avoid bad worst-case behavior, which is due to high point location time. Our BrioDC implementation shows that point location time can be reduced by 25% and our squarified space-filling curve orders show the first improvement by reducing this by 3%.

In this paper, we present algorithms for parsing general tree-adjoining languages (TALs). Tree-adjoining grammars (TAGs) have been proposed as an elegant formalism for natural languages. It was an open question for the past ten years as to whether TAL parsing can be done in time $O(n^6 )$. We settle this question affirmatively by presenting an $O(n^3 M(n))$-time algorithm, where $M(k)$ is the time needed for multiplying two Boolean matrices of size $k \times k$ each. Since $O(k^{2.376} )$ is the current best-known value for $M(k)$, the time bound of our algorithm is $O(n^{5.376} )$. On an exclusive-read exclusive-write parallel random-access machine (EREW PRAM), our algorithm runs in time $O(n\log n)$ using ${{(n^2 M(n))} / {\log n}}$ processors. In comparison, the best-known previous parallel algorithm had a run time of $O(n)$ using $n^5 $ processors (on a systolic-array machine). We also present algorithms for parsing context-free languages (CFLs) and TALs whose worst-case run times are $O(n^3 )$ and $O(n^6 )$, respectively, but whose average run times are better. Therefore, these algorithms may be of practical interest.

We show the O(log n) time extract minimum function of efficient priority queues can be generalized to the extraction of the k smallest elements in O(k log(n/k)) time1, which we prove optimal for comparison-based priority queues with o(log n) time insertion. We show heap-ordered tree selection (Kaplan et al., SOSA '19) can be applied on the heap-ordered trees of the classic Fibonacci heap and Brodal queue, in O(k log(n/k)) amortized and worst-case time, respectively. We additionally show the deletion of k elements or selection without extraction can be performed on both heaps, also in O(k log(n/k)) time. Surprisingly, all operations are possible with no modifications to the original Fibonacci heap and Brodal queue data structures. We then apply the result to lazy search trees (Sandlund & Wild, FOCS '20), creating a new interval data structure based on selectable heaps. This gives optimal O(B+n) time lazy search tree performance, lowering insertion complexity into a gap Δi from O(log(n/|Δi|) + log log n) to O(log(n/|Δi|)) time. An O(1) time merge operation is also made possible when used as a priority queue, among other situations. If Brodal queues are used, all runtimes of the lazy search tree can be made worst-case.