SprayLists: Provably Correct Approximate Priority Queues in a Shared Memory Setting

An important data structure well understood in sequential settings is the priority queue, which supports the following three operations: insert(x), which inserts an item with priority x, delete(x), which deletes the item with priority x, and deleteMin, which deletes and returns the item with lowest priority. Fibonacci heaps [4] support deleteMin and delete in amortized logarithmic time, and insert in constant time, running times which are close to the information theoretic lower bound. It is known that under the “wall clock” model of timing in the distributed setting, even queues have a linear lower bound for some process ([3]). Thus, while there has been a lot of work on provably correct priority queues in the distributed setting (see [2] for a survey), none of them have low collision rates, and indeed, it is straightforward to give executions for which the above problem must occur. However, enforcing the strict priority queue property in a shared memory setting is somewhat silly, as if there are p processes, and all of them simultaneously call deleteMin, then one process must obtain the element with the pth lowest priority at the time of the call anyways. This motivates us to instead consider approximate priority queues, in which a deleteMin operation is only required to return anything amongst the Õ(p) elements with lowest priority. A similar data structure was implemented by [1] in the sequential setting, where to get around a similar information theoretic lower bound, they allow a small fraction of elements to become corrupted in a Binomial-tree-like structure, which allows them to obtain O(log 1 ) running times, if an fraction of inputs are allowed to become corrupted. We present a possible implementation of such an approximate priority queue that breaks the linear lower bound, using a data structure called skip list ([8], [7], [10], [9]). We alter deleteMin to use a new operation called spraying. We demonstrate the correctness of this operation, and that in a restricted model of asynchronicity, spraying, and thus deleteMin, takes polylogarithmic time. The rest of this report is laid out as follows. In section 2 we describe the model and skip lists in detail. In section 3 we motivate and describe our spraying algorithms, as well as our model of asynchronicity. In sections 4, 5, 6 we prove the correctness and efficiency of spraying, and finally in section 7 we give directions of for future work.