A Scalable, Correct Time-Stamped Stack

Abstract

Concurrent data-structures, such as stacks, queues, and deques, often implicitly enforce a total order over elements in their underlying memory layout. However, much of this order is unnecessary: linearizability only requires that elements are ordered if the insert methods ran in sequence. We propose a new approach which uses timestamping to avoid unnecessary ordering. Pairs of elements can be left unordered (represented by unordered timestamps) if their associated insert operations ran concurrently, and order imposed as necessary by the eventual remove operations.We realise our approach in a new non-blocking datastructure, the TS (timestamped) stack. In experiments on x86, the TS stack outperforms and outscales all its competitors -for example, it outperforms the elimination-backoff stack by factor of two. In our approach, more concurrency translates into less ordering, giving less-contended removal and thus higher performance and scalability. Despite this, the TS stack is linearizable with respect to stack semantics.The weak internal ordering in the TS stack presents a challenge when establishing linearizability: standard techniques such as linearization points work well when there exists a total internal order. We present a new stack theorem, mechanised in Isabelle, which characterises the orderings sufficient to establish stack semantics. By applying our stack theorem, we show that the TS stack is indeed correct. Our theorem constitutes a new, generic proof technique for concurrent stacks, and it paves the way for future weaklyordered data-structure designs.

Fast, multicore-scalable, low-fragmentation memory allocation through large virtual memory and global data structures

“…This is the expensive case, only performed on spans with large real-span size determined by a threshold, 5 // Utility f u n c t i o n s to map spans and real -span 6 // sizes to distinct indexes . 7 Int r e a l _ s p a n _ i d x( Span span ) ; 8 Int r e a l _ s p a n _ i d x( Int r e a l _ s p a n _ s i z e) ; 9 10 // Returns the real span size of a given span . 11 Int r e a l _ s p a n _ s i z e( Span span ) ; r e t u r n arena .…”

“…We are aware of lock-free implementations of deques [7] that can be enhanced to be usable in scalloc. However, the process of cleaning up the set at thread termination (see below) requires wait-freedom as other threads may still be accessing the data structure.…”

“…To explain the differences in memory access time we pick the data points for ptmalloc2 and scalloc at x=60% where the difference in memory access time is most significant and compare the number of all hardware events obtainable using perf 7 . While most numbers are similar we identify two events where the numbers differ significantly.…”

Proving Linearizability Using Partial Orders

“…Given (ii), a linearization must satisfy the sequential specification of a queue, so the dequeue must return the oldest enqueued value. Hence, the execution in Figure 1 has three possible linearizations: [Enq(1); Enq(2); Enq(3); Deq():1], [Enq(1); Enq(3); Enq(2); Deq():1] and [Enq (2); Enq(1); Enq(3); Deq():2]. This means that the dequeue is allowed to return 1 or 2, but not 3.…”

“…This must occur somewhere between the start and end of the operation, to ensure that the linearization preserves the real-time order. For example, when applying the linearization point method to the execution in Figure 1, by point (A) we must have decided if Enq(1) occurs before or after Enq (2) in the linearization. Thus, by this point, we know which of the three possible linearizations matches the execution.…”