Queue Data Structure Research Articles

Beacon-Based Uplink Transmission for LoRaWAN Direct to LEO Satellite Internet of Things

Direct-to-satellite IoT (DtS-IoT) communication structure is a promising solution to provide connectivity and extend the coverage of traditional low-power and long-range technologies, especially for isolated and remote areas where deploying traditional infrastructure is impracticable. Despite their bounded visibility, the Low Earth Orbit (LEO) satellites complement the terrestrial networks, offering broader gateway coverage and terrestrial network traffic offloading. However, the dynamics of LEO and the nature of such integration come with several challenges affecting the efficacy of the network. Therefore, this paper proposes Beacon-based Uplink LoRaWAN (BU-LoRaWAN) to enhance satellite-terrestrial communication efficiency. The proposed scheme exploits the LoRaWAN class B synchronization mechanism to provide efficient uplink transmission from LoRaWAN devices placed on the ground to satellite gateways. BULoRaWAN proposes an uplink transmission slot approach to synchronize ground devices’ uplink traffic with LEO-based orbiting gateways. It also uses a queue data structure to buffer end devices’ ready-to-send packets until the appropriate moment. BU-LoRaWAN avoids possible transmission collision by optimizing a random transmission slot for an end device within the beacon window. The proposed system is implemented and evaluated using OMNeT++ network simulator and FLoRaSat framework. The result demonstrates the feasibility of the proposed system. BU-LoRaWAN achieves better performance compared to the standard LoRaWAN, which manages to deliver almost double the traffic delivered by the standard one.

A New Vista of Performing Insertion and Deletion in Linked Lists

Insertion and deletion in linked lists. Linked lists are an example of linear data structures. They are made up of nodes which are connected to each other. The data can be accessed by sequential manner. In this paper we will create an abstract model of linked list where the creation of a linked list of n nodes will take a time complexity of O(n) and the insertion and deletion will take a time complexity of O(1) or constant time at the tail position and head position and also reduce the runtime of insertion and deletion at middle or any index in between to some extent. This abstract model of the linked list can also be used as a stack and a queue because it will contain all properties of stack and queue data structures.

BQ: A Lock-Free Queue with Batching

Concurrent data structures provide fundamental building blocks for concurrent programming. Standard concurrent data structures may be extended by allowing a sequence of operations to be submitted as a batch for later execution. A sequence of such operations can then be executed more efficiently than the standard execution of one operation at a time. In this article, we develop a novel algorithmic extension to the prevalent FIFO queue data structure that exploits such batching scenarios. An implementation in C++ on a multicore demonstrates significant performance improvement of more than an order of magnitude (depending on the batch lengths and the number of threads) compared to previous queue implementations.

A New Algorithm for Extracting Textual Maximal Frequent Itemsets from Arabic Documents

In this paper, a new technique has been suggested for extracting textual maximal frequent itemsets named Maximal Itemset Miner Algorithm (MIMA). This algorithm begins search process through generating the best initial border in search space depending on minimum support of items in the first level that achieves the general minimum support determined by the user. Our approach for counting itemsets support combines the idea of vertical representation of the data with a queue data structure to store the itemsets. To reduce search space, the algorithm adopted several pruning conditions for each itemsets in the initial border. Experiments performed on standard textual CNN Arabic dataset and proposed method registers less execution time comparing with the Apriori algorithm when applying it on three different size datasets.

Combining Several Substitution Cipher Algorithms using Circular Queue Data Structure

With the revolutionized expansion of the Internet, worldwide information increases the application of communication technology, and the rapid growth of significant data volume boosts the requirement to accomplish secure, robust, and confident techniques using various effective algorithms. Lots of algorithms and techniques are available for data security. This paper presents a cryptosystem that combines several Substitution Cipher Algorithms along with the Circular queue data structure. The two different substitution techniques are; Homophonic Substitution Cipher and Polyalphabetic Substitution Cipher in which they merged in a single circular queue with four different keys for each of them, which produces eight different outputs for every single incoming letter. The present work can be applied efficiently for personal information security and network communication security as well, and the time required for ciphering and deciphering a message is less than 0.1 sec.

Hyperqueues

The hyperqueue is a programming abstraction for queues that results in deterministic and scale-free parallel programs. Hyperqueues extend the concept of Cilk++ hyperobjects to provide thread-local views on a shared data structure. While hyperobjects are organized around private local views, hyperqueues provide a shared view on a queue data structure. Hereby, hyperqueues guarantee determinism for programs using concurrent queues. We define the programming API and semantics of two instances of the hyperqueue concept. These hyperqueues differ in their API and the degree of concurrency that is extracted. We describe the implementation of the hyperqueues in a work-stealing scheduler and demonstrate scalable performance on pipeline-parallel benchmarks from PARSEC and StreamIt.

Enhancement of Data Security using Circular Queue Based Encryption Algorithm

Data security is a progressing provocation for designers and Hackers. To battle different attacks by hackers, there is a need for increasingly solid security advancements. In this proposed system, a low complexity circular queue data structure security algorithm can be created. Numerous complicating variable components are used to enhance the quality of this algorithm and make recuperation of original message for hackers, becomes progressively troublesome. These tunable components are the size of the circular queue, the start of the picked keyword letter and the various portrayals of a number are in the Fibonacci manner. All letters ought to be changed over into ASCII binary configuration so as to be utilized by security algorithm in the sensible and shift operations. The outcomes demonstrate that our proposed security algorithm has half low complexity than analyzed multiple circular queues algorithm (MCQA). Fibonacci manner and variable number of difficult factors in this algorithm give adaptability in changing the security of the algorithm as per the conditions. Circular queue is an data structure can be utilized in the data security to make figured message progressively hard to disentangle. For example, a calculation that utilizes the moving and supplanting tasks of bi-section bi-push for round line to expand security. An irregular number was utilized in this algorithm to control the moving between the line and section, in the end this lead to expand the unpredictability of plaintext decrypting.

A dynamic, unified design for dedicated message matching engines for collective and point-to-point communications

The Message Passing Interface (MPI) libraries use message queues to guarantee correct message ordering between communicating processes. Message queues are in the critical path of MPI communications and thus, the performance of message queue operations can have significant impact on the performance of applications. Collective communications are widely used in MPI applications and they can have considerable impact on generating long message queues. In this paper, we propose a unified message matching mechanism that improves the message queue search time by distinguishing messages coming from point-to-point and collective communications and using a distinct message queue data structure for them. For collective operations, it dynamically profiles the impact of each collective call on message queues during the application runtime and uses this information to adapt the message queue data structure for each collective dynamically. Moreover, we use a partner/non-partner message queue data structure for the messages coming from point-to-point communications. The proposed approach can successfully reduce the queue search time while maintaining scalable memory consumption. The evaluation results show that we can obtain up to 5.5x runtime speedup for applications with long list traversals. Moreover, we can gain up to 15% and 94% queue search time improvement for all elements in applications with short and medium list traversals, respectively.

Quantitative Analysis of Dynamic Fault Trees by means of Monte Carlo Simulations: Event-Driven Simulation Approach

The reliability analysis of complex and dynamic systems is often achieved by a quantitative analysis of dynamic fault trees (DFT), which model the system failure, i.e. a specific undesired event called top event, in terms of failures of the components of the system. Indeed, DFT takes into account the sequential relationships among events and their statistical dependencies. Given the failure probability of the components, the quantitative analysis aims at numerically evaluating, among other things, the failure probability of the top event. In this paper, we are interested in the Monte Carlo simulation which can consider any kind of failure distribution and is not limited in the DFT representation: it considers DFT with repeated events and shared events, takes into account all dynamic gates (PAND, SEQ, FDEP, and SPARE). However, Monte Carlo simulation encounters some disadvantages: an entirely new simulation must be executed every time a parameter changes and it may be time-consuming when the desired accuracy is high. To address these difficulties, this paper proposes a new dynamic fault tree simulation performed by an event-driven simulator. With this approach, gate simulations that produce no change in the output of a gate are eliminated augmenting the speed up of the simulation. The implementation of our approach uses an event queue data structure and an event-scheduler as alternative to the usual time-driven implementation which is characterized by an iterative loop. Thus, periods of inactivity are omitted. As results, computational efficiency is obtained and the speed-up performance of the Monte Carlo simulation program is improved.

Dynamizing Dijkstra: A solution to dynamic shortest path problem through retroactive priority queue

Dynamic shortest path algorithms are the ones which are used to accommodate the online sequence of update operations to the underlying graph topology and also facilitate the subsequent query operations. Many solutions exist for the different versions of the problem, all of which identify the set of vertices whose shortest paths may be affected by the changes and then update their shortest paths according to the update sequence. In this paper, we are dynamizing the Dijkstra algorithm which helps to efficiently solve the dynamic single source shortest path problem. Dynamization is achieved by using the retroactive priority queue data structure. Retroactive data structure identify the set of affected vertices step by step and thus help to accommodate the changes in least number of computations. So, with a suitable dynamic graph representation and the use of retroactive priority queue, we have proposed algorithm to dynamize Dijkstra algorithm giving solution of dynamic single source shortest path problem with complexity O(nlg m) for the update time. We have performed experimental analysis by comparing the performance of the proposed algorithm with other algorithms. Our experimental results indicate that the proposed algorithm has better performance in terms of time and memory usage.

Contention-sensitive data structures and algorithms

A contention-sensitive data structure is a concurrent data structure in which the overhead introduced by locking is eliminated in common cases, when there is no contention, or when processes with non-interfering operations access it concurrently. When a process invokes an operation on a contention-sensitive data structure, in the absence of contention or interference, the process must be able to complete its operation in a small number of steps and without using locks. Using locks is permitted only when there is interference. We formally define the notion of contention-sensitive data structures, propose four general transformations that facilitate devising such data structures, and illustrate the benefits of the approach by implementing a contention-sensitive consensus algorithm, a contention-sensitive double-ended queue data structure, and a contention-sensitive election algorithm.

Adaptive Real-Time Communication for Wireless Cyber-Physical Systems

Low-power wireless technology promises greater flexibility and lower costs in cyber-physical systems. To reap these benefits, communication protocols must deliver packets reliably within real-time deadlines across resource-constrained devices , while adapting to changes in application requirements (e.g., traffic demands) and network state (e.g., link qualities). Existing protocols do not solve all these challenges simultaneously, because their operation is either localized or a function of network state, which changes unpredictably over time. By contrast, this article claims a global approach that does not use network state information as input can overcome these limitations. The Blink protocol proves this claim by providing hard guarantees on end-to-end deadlines of received packets in multi-hop low-power wireless networks, while seamlessly handling changes in application requirements and network state. We build Blink on the non-real-time Low-Power Wireless Bus (LWB) and design new scheduling algorithms based on the earliest-deadline-first policy. Using a dedicated priority queue data structure, we demonstrate a viable implementation of our algorithms on resource-constrained devices. Experiments show that Blink (i) meets all deadlines of received packets, (ii) delivers 99.97% of packets on a 94-node testbed, (iii) minimizes communication energy consumption within the limits of the underlying LWB, (iv) supports end-to-end deadlines of 100ms across four hops and nine sources, and (v) runs up to 4.1 × faster than a conventional scheduler implementation on popular microcontrollers.

Extraction of hydrological proximity measures from DEMs using parallel processing

Land surface topography is one of the most important terrain properties which impact hydrological, geomorphological, and ecological processes active on a landscape. In our previous efforts to develop a soil depth model based upon topographic and land cover variables, we derived a set of hydrological proximity measures (HPMs) from a Digital Elevation Model (DEM) as potential explanatory variables for soil depth. These HPMs are variations of the distance up to ridge points (cells with no incoming flow) and variations of the distance down to stream points (cells with a contributing area greater than a threshold), following the flow path. The HPMs were computed using the D-infinity flow model that apportions flow between adjacent neighbors based on the direction of steepest downward slope on the eight triangular facets constructed in a 3 × 3 grid cell window using the center cell and each pair of adjacent neighboring grid cells in turn. The D-infinity model typically results in multiple flow paths between 2 points on the topography, with the result that distances may be computed as the minimum, maximum or average of the individual flow paths. In addition, each of the HPMs, are calculated vertically, horizontally, and along the land surface. Previously, these HPMs were calculated using recursive serial algorithms which suffered from stack overflow problems when used to process large datasets, limiting the size of DEMs that could be analyzed. To overcome this limitation, we developed a message passing interface (MPI) parallel approach designed to both increase the size and speed with which these HPMs are computed. The parallel HPM algorithms spatially partition the input grid into stripes which are each assigned to separate processes for computation. Each of those processes then uses a queue data structure to order the processing of cells so that each cell is visited only once and the cross-process communications that are a standard part of MPI are handled in an efficient manner. This parallel approach allows efficient analysis of much larger DEMs than were possible using the serial recursive algorithms. The HPMs given here may also have other, more general modeling applicability in hydrology, geomorphology and ecology, and so are described here from a general perspective. In this paper, we present the definitions of the HPMs, the serial and parallel algorithms used in their computation and their potential applications.

Wait-free queues with multiple enqueuers and dequeuers

The queue data structure is fundamental and ubiquitous. Lock-free versions of the queue are well known. However, an important open question is whether practical wait-free queues exist. Until now, only versions with limited concurrency were proposed. In this paper we provide a design for a practical wait-free queue. Our construction is based on the highly efficient lock-free queue of Michael and Scott. To achieve wait-freedom, we employ a priority-based helping scheme in which faster threads help the slower peers to complete their pending operations. We have implemented our scheme on multicore machines and present performance measurements comparing our implementation with that of Michael and Scott in several system configurations.

Dynamic workload balancing deques for branch and bound algorithms in the message passing interface

The message passing interface (MPI) is the standard in message passing parallel computation. MPI does not provide a canonical way to dynamically distribute run-time generated workload evenly across all the participating computer nodes. This paper proposes a MPI library to provide near-optimal dynamical workload balancing over branch and bound (B&B) algorithms; B&B potentially produces huge workload unbalance during a parallel execution. The library, named RaWSDM, provides a double ended queue (deque) data structure on which the programmer may pop, process, and later, pull back some parallel tasks; an underlying efficient system scheduler is responsible for keeping the workload balanced by exchanging elements among all deques. Theoretical bounds are traced and practical experiments are performed with the unlimited knapsack problem. Results show a performance gain up to 80% (best-case scenario) against a pure MPI implementation using round-robin scheduling, with near linear speedup and memory consumption.

Approximation of Generalized Processor Sharing With Interleaved Stratified Timer Wheels

This paper presents Interleaved Stratified Timer Wheels as a novel priority queue data structure for traffic shaping and scheduling in packet-switched networks. The data structure is used to construct an efficient packet approximation of general processor sharing (GPS). This scheduler is the first of its kind by combining all desirable properties without any residual catch. In contrast to previous work, the scheduler presented here has constant and near-optimal delay and fairness properties, and can be implemented with O(1) algorithmic complexity, and has a low absolute execution overhead. The paper presents the priority queue data structure and the basic scheduling algorithm, along with several versions with different cost-performance trade-offs. A generalized analytical model for rate-controlled rounded time-stamp schedulers is developed and used to assess the scheduling properties of the different scheduler versions.

Topology cuts: A novel min-cut/max-flow algorithm for topology preserving segmentation in N–D images

Topology is an important prior in many image segmentation tasks. In this paper, we design and implement a novel graph-based min-cut/max-flow algorithm that incorporates topology priors as global constraints. We show that the optimization of the energy function we consider here is NP-hard. However, our algorithm is guaranteed to find an approximate solution that conforms to the initialization, which is a desirable property in many applications since the globally optimum solution does not consider any initialization information. The key innovation of our algorithm is the organization of the search for maximum flow in a way that allows consideration of topology constraints. In order to achieve this, we introduce a label attribute for each node to explicitly handle the topology constraints, and we use a distance map to keep track of those nodes that are closest to the boundary. We employ the bucket priority queue data structure that records nodes of equal distance and we efficiently extract the node with minimal distance value. Our methodology of embedding distance functions in a graph-based algorithm is general and can also account for other geometric priors. Experimental results show that our algorithm can efficiently handle segmentation cases that are challenging for graph-cut algorithms. Furthermore, our algorithm is a natural choice for problems with rich topology priors such as object tracking.

Retroactive data structures

We introduce a new data structuring paradigm in which operations can be performed on a data structure not only in the present, but also in the past. In this new paradigm, called retroactive data structures , the historical sequence of operations performed on the data structure is not fixed. The data structure allows arbitrary insertion and deletion of operations at arbitrary times, subject only to consistency requirements. We initiate the study of retroactive data structures by formally defining the model and its variants. We prove that, unlike persistence, efficient retroactivity is not always achievable. Thus, we present efficient retroactive data structures for queues, doubly ended queues, priority queues, union-find, and decomposable search structures.

An Optimal Cache‐Oblivious Priority Queue and Its Application to Graph Algorithms

We develop an optimal cache-oblivious priority queue data structure, supporting insertion, deletion, and delete-min operations in $O(\frac{1}{B}\log_{M/B}\frac{N}{B})$ amortized memory transfers, where $M$ and $B$ are the memory and block transfer sizes of any two consecutive levels of a multilevel memory hierarchy. In a cache-oblivious data structure, $M$ and $B$ are not used in the description of the structure. Our structure is as efficient as several previously developed external memory (cache-aware) priority queue data structures, which all rely crucially on knowledge about $M$ and $B$. Priority queues are a critical component in many of the best known external memory graph algorithms, and using our cache-oblivious priority queue we develop several cache-oblivious graph algorithms.

Melding priority queues

We show that any priority queue data structure that supports insert , delete , and find-min operations in pq ( n ) amortized time, where n is an upper bound on the number of elements in the priority queue, can be converted into a priority queue data structure that also supports fast meld operations with essentially no increase in the amortized cost of the other operations. More specifically, the new data structure supports insert , meld and find-min operations in O (1) amortized time, and delete operations in O ( pq ( n ) + α( n )) amortized time, where α( n ) is a functional inverse of the Ackermann function, and where n this time is the total number of operations performed on all the priority queues. The construction is very simple. The meldable priority queues are obtained by placing a nonmeldable priority queues at each node of a union-find data structure. We also show that when all keys are integers in the range [1, N ], we can replace n in the bound stated previously by min{ n , N }.Applying this result to the nonmeldable priority queue data structures obtained recently by Thorup [2002b] and by Han and Thorup [2002] we obtain meldable RAM priority queues with O (log log n ) amortized time per operation, or O (√log log n ) expected amortized time per operation, respectively. As a by-product, we obtain improved algorithms for the minimum directed spanning tree problem on graphs with integer edge weights, namely, a deterministic O ( m log log n )-time algorithm and a randomized O ( m √log log n )-time algorithm. For sparse enough graphs, these bounds improve on the O ( m + n log n ) running time of an algorithm by Gabow et al. [1986] that works for arbitrary edge weights.