Using Skip Graphs for Increased NUMA Locality

TL;DR

This paper introduces a skip graph-based data partitioning technique that significantly improves NUMA locality and reduces contention in concurrent data structures, with implementations demonstrating notable performance gains and reduced remote memory accesses.

Contribution

The paper presents a novel skip graph partitioning method that enhances NUMA locality and contention reduction, along with implementations of maps and relaxed priority queues showing competitive performance.

Findings

6x higher CAS locality with lazy skip graphs

68.6% reduction in remote CAS operations

CAS success rate increased from 88.3% to 99%

Abstract

We present a data partitioning technique performed over skip graphs that promotes significant quantitative and qualitative improvements on NUMA locality in concurrent data structures, as well as reduced contention. We build on previous techniques of thread-local indexing and laziness, and, at a high level, our design consists of a partitioned skip graph, well-integrated with thread-local sequential maps, operating without contention. As a proof-of-concept, we implemented map and relaxed priority queue ADTs using our technique. Maps were conceived using lazy and non-lazy approaches to insertions and removals, and our implementations are shown to be competitive with state-of-the-art maps. We observe a 6x higher CAS locality, a 68.6% reduction on the number of remote CAS operations, and a increase from 88.3% to 99% CAS success rate when using a lazy skip graph as compared to a control skip list (subject to the same codebase, optimizations, and implementation practices). Qualitatively speaking, remote memory accesses are not only reduced in number, but the larger the NUMA distance between threads, the larger the reduction is. We consider two alternative implementations of relaxed priority queues that further take advantage of our data partitioning over skip graphs: (a) using ``spraying'', a well-known random-walk technique usually performed over skip lists, but now performed over skip graphs; and (b) a custom protocol that traverses the skip graph deterministically, marking elements along this traversal. We provide formal arguments indicating that the first approach is more \emph{relaxed}, that is, that the span of removed keys is larger, while the second approach has smaller contention. Experimental results indicate that the approach based on spraying performs better on skip graphs, yet both seem to scale appropriately.

Tables

Table 1. Table 1: Average (instructions & data) cache misses per operation , HC-WH, 96 threads. Numbers collected with PAPI.

totals	lazy_sg			map_sg			map_ssg			sl
	L1	L2	L3	L1	L2	L3	L1	L2	L3	L1	L2	L3
8	52.8	12.6	3.1	56.5	12.4	3.1	57.6	12.5	2.7	65.0	15.1	3.1
16	53.6	14.5	3.4	55.9	13.7	3.0	59.0	14.1	3.1	73.1	16.7	3.5
32	87.5	18.7	3.5	73.9	14.5	3.0	93.7	18.1	2.9	93.0	24.6	3.7

Table 2. Table 2: 96 threads, HC-WH. CAS/op does not include uncontended CAS operations upon node insertion. Comparing the lazy map/sg with the skip list, we can observe  6x more CAS locality, 65% less CAS/operation, and substantially better CAS success rate.

	lazy map/sg	map/sg	map/ssg	skip list
local reads/op	9.105	8.933	4.264	0.477
remote reads/op	48.076	54.521	65.123	45.392
local maintenance CAS/op	0.02508	0.177	0.0137	0.012
remote maintenance CAS/op	0.3493	2.524	0.888	1.113
CAS success rate	0.999	0.986	0.982	0.883

Equations

$$\sum _{i=0}^{\log T-1}{a}_i{2}^i=\bar{x},$$

$$a_k(0)+a_{k-1}(1)+\dots +a_0(k)+c\equiv \bar{x}(k)\mathrm{mod}2,$$

$$\mathtt{F}(\mathtt{x}{)}_{\mathtt{j}}\le \mathtt{Pr}[{\mathtt{a}}_0\text{ is a }\mathtt{match}]\prod _{\mathtt{i}=1}^{\log \mathtt{T}-1}\mathtt{Pr}[{\mathtt{a}}_{\mathtt{i}}\text{ is a }\mathtt{match}|{\mathtt{A}}_{\mathtt{i}-1}],$$

$$\mathtt{Pr}[{\mathtt{a}}_0\text{ is a }\mathtt{match}]\prod _{\mathtt{i}=1}^{\log \mathtt{T}-1}\mathtt{Pr}[{\mathtt{a}}_{\mathtt{i}}\text{ is a }\mathtt{match}|{\mathtt{A}}_{\mathtt{i}-1}]=\frac{1}{2^{\log \mathtt{T}}}=\frac{1}{\mathtt{T}}.$$

$$\mathtt{F}(\mathtt{x}{)}_{\mathtt{j}}=\mathtt{Pr}[{\mathtt{a}}_0\text{ is an }\mathtt{exact}\mathtt{match}]\prod _{\mathtt{i}=1}^{\log \mathtt{T}-1}\mathtt{Pr}[{\mathtt{a}}_{\mathtt{i}}\text{ is an }\mathtt{exact}\mathtt{match}|{\mathtt{A}}_{\mathtt{i}-1}],$$

$$E[X]=E[\sum _{i=1}^T{X}_i]=\sum _{i=1}^{T}E[X_i]=\sum _{i=1}^T\frac{T}{T-i+1}=T\sum _{i=1}^T\frac{1}{i}=T\cdot H(T),$$

$$H(T)$$

Full text

We consider two alternative implementations of relaxed priority queues that further take advantage of our data partitioning over skip graphs: (a) using “spraying”, a well-known random-walk technique usually performed over skip lists, but now performed over skip graphs; and (b) a custom protocol that traverses the skip graph deterministically, marking elements along this traversal. We provide formal arguments indicating that the first approach is more relaxed, that is, that the span of removed keys is larger, while the second approach has smaller contention. Experimental results indicate that the approach based on spraying performs better on skip graphs, yet both seem to scale appropriately.

1 Introduction

The increasing availability of computing cores on shared memory machines makes concurrent data structure design a critical factor for application performance. Non-blocking[26], linearizable [24] structures are particularly appealing, since they can effectively replace sequential or blocking (lock-based) structures without compromising the semantics expected by the programmers. However, the design landscape for concurrent structures is changing: NUMA architectures emerge as a set of computing/memory “nodes” linked by an interconnect, making memory accesses within the same NUMA node cheaper than those made across different NUMA nodes.

Under the usual assumption that threads are pinned to cores, we adopt the definition of local memory accesses as those operating in memory initially allocated by the current thread (under first-touch NUMA policy), and remote accesses as those accesses that are non-local. Note that our definitions are conservative, as data initially allocated by two different threads could indeed be located within the same NUMA node. Our goal is to increase NUMA locality – the ratio of local over total memory accesses, and research is very active in this area. Some approaches [32, 7, 11] focus on redesigning data structures with NUMA awareness, which is effective as we have full ability to exploit the structure’s internal features for the task. Unfortunately, complete redesigns can pose significant development and research efforts, unsuitable for non-specialists. On the other hand, approaches like [9] allow sequential structures to be “plugged-in” and benefit from NUMA-aware concurrency, based on replicating the dataset among nodes, batching local operations, and coordinating batches as to minimize inter-node traffic.

Our contributions. We present a data partitioning technique based on using skip graphs [5, 1] in order to promote significant quantitative and qualitative improvements in NUMA locality in concurrent data structures, as well as reduced contention. By qualitative improvement, we mean that remote memory accesses are not only reduced in number, but the larger the NUMA distance between threads, the larger the reduction is (Sec. 6). At a high level, skip graphs can be viewed as multiple skip lists that overlap in a structured way in multiple levels, so we partition sub-components of those skip graphs among threads, taking advantage of its structure, in a way that makes the dataset to be operated with much higher NUMA locality. Skip graphs are expensive data structures, so our technique is made viable in practice by using thread-local indexing and well-documented laziness principles [11, 10] into our design. As a proof-of-concept of our data partitioning technique, we implemented maps and relaxed priority queues [22, 40, 39, 3]. Maps have been implemented with and without using laziness techniques, but always using thread-local indexing similarly to [11]. We are competitive with state-of-the-art maps [11, 10, 13]: in some cases, we see 80% increased performance, while in others, we see similar performance to the faster running implementation. As part of our NUMA locality assessment, we observe a 6x higher CAS locality, a 68.6% reduction on the number of remote CAS operations, and an increase from 88.3% to 99% of CAS success rate when using a lazy skip graph map implementation, as compared to our control – a skip list subject to the same codebase, optimizations, and implementation practices. Memory access patterns are visualized on Sec. 6, and the qualitative improvement introduced with our technique is evident.

We also contribute with relaxed priority queues [22, 40, 39], which return an element among the $k$ smallest elements in a set, rather than the absolute smallest. We not only use our data partitioning technique, which brings increased NUMA locality and reduced contention, but we consider a couple of algorithmic choices that further harness key structural features of the skip graph: (a) using spraying [3], a well-known random-walk technique usually performed over skip lists, but now performed over skip graphs; and (b) a custom protocol that traverses the skip graph deterministically, marking elements along this traversal. In either case, our NUMA locality improvements, discussed above, still apply, and we do verify experimentally that both approaches perform about 5x-9x faster than our control, which is a spray performed over a skip list, but one implemented with the same codebase and practices as the approaches (a) and (b) above. Additionally, we provide a formal argument indicating that our custom protocol (b) is slightly less relaxed (Theorem. 2), that is, that the span of removed keys is slightly smaller (but still the same asymptotically), but our approach is subject to smaller contention: Theorems 3 and 4 indicate that each node is subject to contention from only two threads in our custom algorithm.

Skip graphs as defined in [5, 1] have expensive insertions and removals compared to skip lists, related to the expected number of levels nodes insert/remove themselves to/from. Our skip graphs, however, can have a reduced height as we pair them with thread-local indexes (used also in [11]). Furthermore, we also employ laziness [11, 10] in our variant implementations (maps and relaxed priority queues), as we build internal skip graph links only when necessary (and, symmetrically, we destroy internal links only when deemed appropriate). Using these techniques not only grants the performance benefits previously documented in the literature [11, 10], but make skip graphs viable in the first place, which promotes further benefits on increased NUMA locality. Among the most crucial benefits is the qualitative improvement on the memory access pattern among threads, discussed and visualized on Sec. 6. We anticipate that qualitative improvement to become increasingly significant in future NUMA systems, as we conjecture increasingly larger hierarchical cost structures for remote memory accesses in upcoming NUMA systems.

We proceed with an overview and background in Sec. 2, and related work on Sec. 3. Design and implementation are further discussed in Sec. 4, with evaluation in Sec. 6 and conclusion in Sec. 7.

2 Architecture Overview and Background

Our layered structure consists of many local structures, which are thread-local, sequential, navigable indexes (e.g., a C++ map), one assigned per thread, as well as a single shared structure, which is a skip graph (or a slight variant thereof). The local structures are used to “jump” to positions in the shared structure near to where insertion, removal, and contain operations will complete, which certainly contributes to reducing remote memory accesses. Once in the shared structure, our data partitioning scheme over the skip graph promotes a further reduction in remote memory accesses due to its internal structure. We say nodes store elements, although we use these terms interchangeably. When necessary, we further distinguish between local nodes or shared nodes, as we refer to nodes belonging to a local structure or to the shared structure, respectively. Each local structure’s job is to map elements inserted by their owning thread to the corresponding shared node in the skip graph. Inserting an element $e$ adds a shared node s to the skip graph, and creates a mapping $e\rightarrow\mathtt{s}$ in the local structure of the inserting thread. A subsequent removal of element $e$ will (i) logically delete the shared node s in the skip graph, (ii) cause a physical cleanup to occur in the shared structure and (iii) cause the thread that contains the mapping $e\rightarrow\mathtt{s}$ in its local structure to physically cleanup that association upon detection. Steps (ii) and (iii) can happen in any order. Discussion of insertion and removal definitions can be found in Sec. 4.

Skip Graphs. Fig. 1 depicts a skip graph, and performs the role of the shared structure. It is composed of multiple singly-linked lists at different levels (Fig. 1). Starting from level zero, each level $i$ contains $2^{i}$ lists. All elements belong to the level-0 list, labeled as “$\lambda$”, the empty string. The level-0 list is partitioned into two level-1 lists, labeled “0” and “1”. Each level-1 list is further partitioned into two level-2 lists: the level-1 list labeled “0” (resp. “1”) is partitioned in two level-2 lists, labeled “00” and “01” (resp. “10” and “11”). The specific partitioning of elements (described ahead) is not done in a probabilistic way as in the original skip graph: we have a partitioning scheme that assigns threads to levels.

A skip graph can be seen as a collection of skip lists sharing their levels. In Fig. 1, we denote by $H=(\lambda,0,00)$ a skip list formed by the highlighted nodes, one among four other skip lists that together constitute the skip graph. The element 35 is in the maximum level of $H=(\lambda,0,00)$. We refer to any skip list within the skip graph as shared skip list, and any of the individual linked lists within the skip graph as a shared linked list. All elements belong to one shared skip list in all of its levels, so we can always perform a skip list search starting from that node’s top level, traversing only the skip list that the node belongs to in its top level. For instance, in Fig. 1, we can search for $83$ starting at $52$, following the shared skip list $(\lambda,1,11)$ through the following path: 52 $\rightarrow$ 68, $\downarrow$, 68 $\rightarrow$ 80, $\downarrow$, 80 $\rightarrow$ 83. Hence, despite a richer structure, it is important to notice that skip graph searches are skip list searches.

Data Partitioning. Even though the skip graph is shared by all threads, we limit where each thread operates on it, configuring a partition scheme. We consider a system of $T$ threads $\{t_{0}\ldots t_{T-1}\}$. The skip graph’s maximum level is denoted by $\mathrm{MaxLevel}$, and we have that $\mathrm{MaxLevel}=\lceil\log(T)\rceil-1$. Such a “low” $\mathrm{MaxLevel}$ does not guarantee logarithmic searches on a skip graph standing by itself, but our local structures compensate this fact by “jumping” to positions in the skip graph near where operations take place. Each thread $T_{i}$ will have a membership vector $M_{i}$, a sequence of $\mathrm{MaxLevel}$ bits, whose suffixes indicate the only shared skip list that $T_{i}$ can operate, which we denote $L_{i}$ and also call the associated skip list of $T_{i}$. This causes all insertions from a single thread to happen in a unique skip list within the skip graph. As an example, consider the skip graph with $\mathrm{MaxLevel}=2$ of Fig. 1. Each thread will have a 2-bit membership vector. If $T_{i}$ has $M_{i}=$ “10”, say, then $T_{i}$ will always insert or remove in the skip list $L_{i}=(\lambda,0,10)$. At most two threads operate in each of the top-level shared linked lists, and at most $T/2^{i}$ threads operate in any particular level-$i$ list.

Note that the original definition of skip graphs assumes a membership vector per element, but our approach has all elements inserted by a single thread to follow the thread’s membership vector. Further, membership vectors are generated according to physical NUMA features of the machine (see Sec. 6). We make threads that run on nearby CPUs share more linked lists than threads that run on distant CPUs in the NUMA system. For example, consider a system where we have $T=16$ threads ($\mathrm{MaxLevel}=3$), with 2 NUMA nodes, each with 2 CPUs, each of those with 2 cores, each of those with 2 hyperthreads. We will give the same membership vector for any two threads running on hyperthreads of the same core; membership vectors with a common 2-bit suffix if threads run on different cores, and with a common 1-bit suffix if threads run on different CPUs; and finally membership vectors with no common suffix if threads run on different NUMA nodes. Now, on the level-3 linked lists, any contention relates to core-local data (and hopefully located on the core’s closest cache); on the level-2 linked lists, any contention relates to CPU-local data; on the level-1 lists, any contention relates to NUMA-local data. Not only we expect less contention in upper-level lists, because they are shared among less threads, but we expect this contention to relate to more local data. Further, any search that traverses the skip graph, as we discussed, is a skip list search. Hence, we first traverse core-local data, and if we go down a level, the target data cannot be located in the same core. Similarly, we then traverse CPU-local data, then NUMA-local data, and if we ever go down a level, the target data must be found remotely, where local/remote depend on the level in question. If we ever leave, say, a NUMA node, we never come back to it. The same applies to CPU-local data, or core-local data, and this happens as a direct consequence of our data partitioning mechanism, based on careful attribution of membership vectors. We have an automated mechanism that generates membership vectors based on inspecting the system’s CPU/socket/domain structure, and we indeed verify less contention (substantial improvement on CAS success ratio) and more locality (visualized graphically) in Sec. 6.

Alternative shared structure: Sparse Skip Graphs. In order to further explore benefits and tradeoffs of skip graphs, we also created and tested a second shared structure, called a sparse skip graph (Fig. 2). This structure is a skip graph where elements are present in level $i$ of any shared skip list with expectation $1/{2^{i}}$, just like in a regular skip list.

The sparse skip graph is still a set of skip lists sharing their levels, although the levels overall become more and more sparse like a skip list. The combination of skip graph partitioning and skip list refinement makes elements be present in level $i$ of a particular linked list with expectation $1/{4^{i}}$. For instance, in Fig. 1, each of the level-1 lists “0” and “1” would partition only 50% of the elements of “$\lambda$”, which would be selected at 50% chance independently. So, “0” and “1” would each have about 25% of the elements in “$\lambda$”. Similarly, the level-2 lists “00” and “01” would partition only 50% of the elements of “0”, each selected at 50% chance, independently. So, lists “00” and “01” would each have about 6.25% of the elements in “$\lambda$”. Importantly, in our technique, only elements that reach the top level are added to the local structures. Therefore, sparse skip graphs also cause the local structures to become more sparse. This is crucial because the local structures, besides pointing to shared nodes nearby the target destinations, should also point to maximum-level nodes from which we can start an efficient search. Hence, using sparse skip graphs gives two immediate advantages: (i) the local structures are smaller; and (ii) the insertion and removal in the shared structure requires changes in less than $\mathrm{MaxLevel}$ levels. The tradeoff is that the starting point given by the local structures is not as close to the requested element compared to regular skip graphs.

3 Related Work

Data intensive applications. Applications, particularly DBMSs, are not only concerned with data placement (somewhat related to our goals), but also with task scheduling (a non-goal here). Some approaches consider NUMA locality in the query evaluation and planning [28, 17, 29], and others do at the OS level [38]. We have a simple approach to data placement: threads index their inserted elements locally and the dataset is effectively partitioned; our focus is on the data access pattern. Systems such as [37] are particularly concerned with data access pattern issues, as their operations are mostly uniform among threads. We do not discuss task scheduling, as we do not rely on approaches such as delegation [6, 27] or flat-combining [20, 14], which do bring concerns related to this issue because of the non-uniform work division among threads.

Skip Lists and Skip Graphs. Skip lists first appeared in [34], although [25, 30, 16] were most widely discussed in the literature [23]. Skip lists have also been used to implement priority queues, either exact [8, 35, 36] or with a relaxed definition [22, 40, 39, 3]. SkipNets [1] are similar (if not identical) to skip graphs, proposed relatively at the same time. We consider those equivalent, and equally applicable. Skip graph variations, such as in [18], typically address issues related to distributed systems, such as node size; we are aware of a single concurrent implementation in shared memory in [31], although it is lock-based, in contrast with both of our lock-free variants. Our implementation relies heavily on laziness, as we postpone much of the internal work until they are absolutely needed. The “No Hotspot” skip list [10] uses similar lazy principles, albeit with a different protocol. The “Rotating” skip list has a novel construction (“wheels”) meant to improve cache efficiency and locality, and also constitutes a modern, state-of-the-art implementation.

NUMA awareness and layered design. The work presented in [12] gives a systematic approach to provide NUMA-awareness to locks. Tailor-made data structures for NUMA systems, such as [32, 7] have also been developed, using (now) standard techniques such as elimination [21] and delegation [6]. We think that “blackbox” approaches, such as in [9], are interesting as they relieve systems programmers from “customizing” their data structures for NUMA, a notoriously complicated task for non-specialists (and specialists alike [23]). NUMASK [11] is an interesting skip list that uses its higher levels as a hierarchical “index” to the bottom-level list, which stores the dataset. In our case, the dataset is located in a structure of its own, a multi-level skip graph. This allows for our data partitioning mechanism, designed to (i) reduce non-local NUMA traffic, and particularly avoid traversals that navigate back and forth across NUMA nodes; and (ii) reduce contention by creating areas within the shared structure where only subsets of threads operate. Our thread-local indexing, similarly, is more detached from the dataset, and could be implemented with any sequential, navigable map. In our implementation, for example, our map is actually a combination of a search tree and a hash table. Finally, our indexes are not replicated, but partitioned. Even with our optional load balancing mechanism in place, threads donate nodes but do not replicate their indexing. Apart from differences of granularity and function, the idea of separating thread-local views and shared views has been seen before in [2], although their approach is more akin to combining, as they eventually merge thread-local views into the shared structure from time to time.

4 Implementation Details

Section 2 gives a design overview, and this section gives more insight into implementation and correctness, and discusses optimizations related to laziness and physical removal. We will discuss first the implementation of map ADTs using our technique, and later highlight the differences in the relaxed priority queue protocols.

General implementation concepts. Our skip graph has a head array pointing to the first shared node in each shared linked list. Each shared node s has a reference array to successors in each level-$i$ list, denoted s.next[i], and also called the level-$i$ reference of s. Each reference has a marked and a valid bit used for lazy removal, and the functions s.getMark(i), getValid(i), s.casMark(i, exp, new), and s.casValid(i, exp, new) operate on s.next[i]. The functions s.getMarkValid(i) and s.casMarkValid(i, (mExp, vExp), (mNew, vNew)) operate on marked and valid bits of s.next[i] simultaneously. The mapping performed by local structures is done through maps that manage local nodes. We can ask a local node $l$ for its key with l.getKey(), and for its value with l.getValue(). The latter always returns a shared node s with the same key as the local node $l$. Traversals in the local structure are done with l.getPrev() or l.getNext(). The local structure for thread $i$, a C++ std::map, is denoted by localstructures[i]. Each has an auxiliary hash table hashtable[i], allowing threads to consult a fast hashtable [4] before consulting a slower map. Therefore, our local structures, in practice, are implemented with two complementary, sequential data structures.

Laziness. State-of-the-art concurrent data structures rely heavily on postponing internal work until they become absolutely needed, in the hope that they become unnecessary. Our lazy layered skip graph employs this principle as: (i) Insertions are done in the level-0 linked list first, and only complete the insertion when the node in question is requested to be in the top level in order to start a search operation. (ii) Removals are performed by “invalidating” a linked node, and nodes are marked for physical removal when the threads that originally inserted those nodes find them invalidated after a minimal commission period for which they exist in the structure. Experimentally (Sec. 6), we found that a commission period proportional to the number of threads, say $350000\cdot T$ cycles, for instance, performs very well under high-contention without introducing too much overhead in low-contention (in the latter, a longer commission period could leave the data structure much larger at times). An alternative to our commission period policy would be having a background thread that started the physical removal of invalid nodes. However, in order to increase NUMA locality, and to preserve the benefits from our data partitioning technique, we want the traversing threads themselves to start this process, using a local synchronization operation. In that context, the commission period becomes a distributed control that avoids nodes to be permanently allocated. (iii) We perform physical removal using our relink optimization (discussed below), but only when substituting a chain of marked references with an inserting node. Although this protocol has the potential to leave too many unmarked nodes in the data structure, we verified experimentally that the actual number of traversed shared nodes per operation is less than in a skip list up to 96 threads.

Physical removal. When a node’s level-0 reference marked (resp. valid) bit is set, we say the shared node is marked (resp. invalid). The concepts of unmarked and valid are obvious. In the non-lazy version, we do not use the valid bit, and in that case an unmarked shared node indicates presence in the abstract key set, while a marked shared node indicates a logically deleted node. In the lazy version, an unmarked, valid node indicates presence in the abstract set; an unmarked, invalid node indicates absence from the abstract set (logically deleted), but also that the process of physically unlinking the node has not started; a marked node can only be invalid, and the process of physically unlinking is ready to start. Each shared node s has a field s.allocTimestamp, set at shared node construction, used to calculate when a node’s commission period has elapsed, thus making it a candidate for physical removal (see the discussion on laziness, above). The removal process happens in distinct phases. (i) A thread that traverses the data structure will mark a shared node with an expired commission period only if such node has been inserted by the thread in question. (ii) When threads remove marked nodes from their local structures, they also mark upper-level references in order to promote physical removal. As in many cases logically deleted nodes have not been inserted in upper levels, upper-level reference marking is not always necessary or complete. (iii) Finally, traversing threads perform the physical cleanup using the relink optimization discussed below.

In textbook skip lists [23], we indicate willingness to physically remove a node s by marking its s.next[i] references for all levels $i\ldots 0$ the node belongs to. Within a level $i$, searches performed on behalf of insertions and removals physically remove nodes with marked next[i] references by employing a single CAS per node. In contrast, both our skip lists or skip graphs remove sequences of marked references with a single CAS per sequence, a trivial optimization that we we denote by relink optimization. The correctness of this protocol is trivial when we consider that marked references are immutable. Algorithmic details are discussed in Appendix A.

Insertion. Algorithms 1, 2, and 3 show the insert operation for key. In insert() (Alg. 1), if the thread finds a reference to a shared node with the goal key (call it result), it invokes insertHelper() (Alg. 2), which atomically checks result’s marked and valid bits and finishes the operation if: (I-i) result was seen as an unmarked valid node, so we linearize a failed insertion right before our check (Alg. 2, line 3). (I-ii) result was atomically changed from invalid to valid, so we linearize the successful insertion right at that time (Alg. 2, line 6). If insertHelper() cannot finish the operation (by returning false), result got marked, so (i) we clean the thread’s local structure (Alg. 2, lines 10 and 11); and (ii) we call lazyInsert() (Alg. 3), which will complete the insertion.

The procedure lazyInsert() (Alg. 3) starts by calling getStart() (Alg. 4), which finds the closest preceding, unmarked shared node pointed by the local structure (line 5). We call this node currentStart. We then perform a search in line 7, starting from currentStart, by calling lazyRelinkSearch() (Alg. 7, page 4). After this search: (I-iii) If an unmarked shared node with the goal key is found (call it successors[0]), a call to insertHelper() (line 9) will define our linearization, just like our previous discussion of Alg. 1. If that call returns false, successors[0] became marked, so we retry the search at line 12. (I-iv) If an unmarked node with the goal key is not found, we try to insert the node on line 14. If the attempt fails, we retry the search until either (I-iv-a) we link the new shared node in line 14, so we linearize at the point the CAS succeeded, noting that shared nodes are allocated as unmarked and valid; or (I-iv-b) find another unmarked shared node with the goal key, reverting to case (I-i). The lazy insertion only happens at level 0. In line 15, updateStart (Alg. 10, Appendix B) makes sure that currentStart is unmarked, otherwise it traverses the local structure backwards and updates currentStart to the closest unmarked shared node seen.

The procedure getStart() (Alg. 4) finds an unmarked shared node pointed by the local structure that closest precede key. It performs an initial search at line 1, then traverses the tree backwards (line 18) for as long as the shared nodes pointed to by the local structure are found marked. Along this traversal, if we find a suitable candidate, but one whose insertion in the upper levels of its shared skip list has not been completed, we call finishInsert() (Alg. 11, Appendix B). This is done at line 6 to try to complete the node’s insertion at upper levels. This call can fail if the node gets marked before all levels are linked, and in that case we continue our traversal. In line 6, the call to updateStart() (Alg. 10, Appendix B) finds a suitable starting point for finishInsert(), but does not finish insertions itself. So, updateStart() is a simplified of getStart() that does not finish insertions lazily, and ignores nodes that are not fully inserted.

Removal and Contains. Removals are similar to insertions, and are performed with three analogous algorithms. We present those in detail in Appendix A, and we give here only an overview. The procedure remove() (Alg. 12, Appendix C) uses the local hashtable to locate a shared node with the goal key. If such node is found, it then tries to linearize an operation by calling removeHelper() (Alg. 13, Appendix C). This algorithm is similar to insertHelper (Alg. 2) for the insertion. When removeHelper() is called over a node, call it result, it may either: (i) See result as an unmarked, invalid node, so we linearize a failed removal right at that time. There cannot exist another unmarked, valid node in this case, which justifies our linearizability. (ii) Successfully unset the valid bit of result, so we linearize the successful removal at that time as well. If we fail to complete either of (i) or (ii), the algorithm lazyRemove() (Alg. 14, Appendix C) will complete the removal (case (iii)). This algorithm essentially uses a search procedure, retireSearch() (Alg. 9, Appendix A) and: (iii-a) If it succeeds locating an unmarked node with the goal key, removeHelper() (line 8) will define our linearization, falling back to (i) or (ii); or (iii-b) If lazyRemoval() fails locating an unmarked node with the goal key, we linearize a failed removal at the time we found the element succeeding that key in the bottom level. Contains is similar yet simpler than insertions. We present the algorithms in detail in Appendix A, and give here only an overview for the sake of space. The algorithm contains() (Alg. 7, Appendix A) first tries to locate an element through the local hashtable. If an unmarked, valid node is found, we linearize a successful contains at this point (case (i)). Otherwise, we call SG::contains() (Alg. 8, Appendix A), which will complete the procedure. This will invoke retireSearch() (Alg. 9, Appendix A), trying to locate an unmarked shared node with the goal key. If one is found: (ii) if we see such node unmarked and valid, we linearize a successful contains at that time. (iii) Otherwise, we linearize a failed contains at the earliest of (i) the time we failed to see the node was unmarked and valid; or (ii) right after the node became marked.

Search. We use two search procedures. We show lazyRelinkSearch() in Alg. 5 below, and retireSearch() in Alg. 9 in Appendix A. Consider the insertion of a new node toInsert. The procedure lazyRelinkSearch() identifies, at all levels: (A) which nodes should precede toInsert (referenced in predecessors); (B) which nodes should succeed toInsert (referenced in successors); and (C) which nodes, referenced in the middle array, had predecessors[i].getNext(i) right at the moment each predecessor predecessor[i] was identified. Between predecessors[i] and successors[i] we have a sequence of nodes with their level-$i$ references marked. We hope these nodes get replaced, through a single CAS operation, with toInsert (hence implementing our relink optimization protocol, p. 4). Importantly, during this process, line 4 uses checkRetire() (Alg. 15, Appendix A) to check if nodes are invalid and their commission period has expired, in which case these nodes get marked. Remove and contains operations use retireSearch(), a slightly quicker variant that does not keep track of predecessors, successors, and middle.

Unbalanced workloads. We provide an optional mechanism for handling unbalanced workloads, and we address the following scenarios: (i) Some threads may only insert, while others only perform removals/contains. (ii) Distinct groups of threads may insert in distinct partitions of the element space. Both scenarios are problematic because threads do not necessarily find good starting points for their search operations if their local structures are empty or skewed towards a partition of the element space. Our load-balancing mechanism is based on having threads donate a fraction of their nodes inserted in the shared structure so they are added to local structures of other threads. A background thread takes into account the number of inserted elements announced by every worker thread, and, based on those numbers, continuously indicates to each worker thread the fraction of inserted nodes that are requested for donation. The worker threads place such fraction of inserted nodes into donation queues (one per worker thread), which are collected by the background thread and distributed uniformly among all other worker threads. Threads inspect receiving queues for incoming nodes, and add them into their local structures. Specifically, if a worker thread $T_{i}$ announces the insertion of $I_{i}$ elements out of a total of $I_{T}=\sum_{\{0\leq i<T\}}I_{i}$ elements, then if $1/T>(I_{i}/I_{T}-1/T)$, then $T_{i}$ donates a fraction of $I_{i}/I_{T}$ of its elements; otherwise, it donates a fraction of $(I_{i}/I_{T}-1/T)$ of them. Some degree of non-uniformity, however, is not expected to impact the shared structure efficiency globally. If shared lists are cleaned less often, then it means these lists are not often operated by threads that share them. Hence, all other threads would be traversing or cleaning over different lists, still operating normally. Also, note that donated nodes have been inserted in their bottom-level by a thread $T_{i}$, while they might be inserted in upper levels by a thread $T_{j},j\neq i$. We are currently working on delegating the creation of upper levels to the original thread $T_{i}$, avoiding to cross NUMA nodes when building up those levels. On lazy implementations, where levels are only built when needed, the impact of this problem is reduced.

Priority Queues. Note that our layered structure can implement a priority queue ADT in addition to sets/maps. Like many alternative priority queues in the literature [35, 36, 8], we mark elements in the bottom level of the skip graph in order to logically delete elements. However, our layered approach gives the opportunity to perform physical cleanup on local structures using combining [20, 14]: because we always remove a whole prefix of the local structure containing logically deleted nodes, many nodes could be removed at once, at cost comparable to a single removal. Besides, our skip graph seems to be suitable to implement relaxed priority queues [22, 40, 39]. We see two immediate approaches: (i) the application of the spraying technique of [3] over skip graphs; and (ii) a custom protocol that traverses the skip graph deterministically, marking elements along this traversal.

Regarding option (i), the main idea of [3] is to disperse threads over the skip list bottom level through a random walk called a spray. If we apply the technique to a skip graph, each thread $T_{i}$ would navigate only through its associated skip list $L_{i}$. We see several advantages of performing spray operations over skip graphs rather than skip lists. Our partitioning scheme will still incur in better memory locality and reduced contention, as discussed before. On the other hand, we show that spraying over skip graphs has a slightly bigger removal range (same asymptotically, but higher nevertheless), as seen in Theorem 2.

Regarding option (ii), we implement a deterministic traversal in the skip graph, marking elements along the way. Informally, a thread $T_{i}$ starts at the highest level of its associated skip list, traverses marked nodes, and attempts to mark at the current position. If the attempt succeeds, a node has been logically deleted, otherwise the thread moves down a level, traverses marked nodes, and proceeds similarly. At level 0, two mark attempts are tried, and upon failing the second one, the process is restarted. This process is shown in Alg. 6 in Appendix 5. We prove, on Theorems 3 and 4, that we have at most 2 threads contending for the same node along the traversal. In other words, the number of CAS operations required to logically delete a sequence of $T$ nodes in our deterministic protocol is $2T$.

5 Analysis of Spray Operations on Perfect Skip Graphs

In this section, we provide formal arguments related to the performance of spray operations as in [3] as applied over skip graphs. Part of the analysis presented here closely follows the aforementioned paper, while others are particular to skip graphs. Recall that $T$ is the number of threads in the system. We will assume that $\log T$ is integral, and that for the number of nodes $N$ in our skip graphs or lists, $N\geq T$ holds. When convenient we will explicitly assume $T=2^{n}$, where $n\geq 1$. The particular variant of skip graphs we refer to, throughout our analysis, is the one where in each level $i$, where $0\leq i\leq\log T-1$, there are $2^{i}$ lists as described in Sec. 2.

5.1 Reach of Skip Graph Spraying

Definition 1**.**

A skip graph is perfect if the absolute value of the difference in the positions of any two consecutive nodes on level $i$ is $2^{i}$, for all $0\leq i\leq\log T-1$.

The operation $\tt{SPRAY(H,L,D)_{j}}$ defines a random walk starting at height $\tt{H}$, i.e., at the head of a list $j$ at level $\tt{H}$ of the skip graph. The walk continues forward to the right a uniformly random number of consecutive nodes chosen from $\tt{[0,L]}$ then moves down the skip graph $\tt{D}$ levels. This is repeated until we reach the bottom list and (possibly) walk forward to the right one last time. Thus the walk ends at position $x$ in the bottom list. We are interested in characterizing the probability that any $\tt{SPRAY}$ operation starting from any $j$ of the $2^{\log T-1}$ lists of the maximum level of the skip graph lands on position $x$ in the bottom list.

Definition 2**.**

Let $j$ be any of the $2^{\log T-1}$ lists of the maximum level of a perfect skip graph, and let $x$ be the position of any node in the perfect skip graph. Then $\tt{F(x)_{j}}$ denotes the probability that for fixed $\tt{H}$, $\tt{L}$, and $\tt{D}$, $\tt{SPRAY(H,L,D)_{j}}$ lands on position $x$ in the bottom list.

In the proof of the theorem below, we closely follow [3] with appropriate changes and modifications for the perfect skip graph. We assume w.l.o.g. that $\log T$ is odd.

Theorem 1**.**

Fix $\tt{H}=\log T-1$, $\tt{L}=\log T$, and $\tt{D}=1$. Then for any position $x$, $\tt{F(x)_{j}}\leq\frac{1}{T}$.

Proof.

Let $j$ be any of the $2^{\log T-1}$ lists of the maximum level of a given skip graph, and let $x$ be the position of any node in the perfect skip graph. Let $pos_{j}$ denote the position of the head of list $j$. If $x<pos_{j}$, then trivially $\tt{F(x)_{j}}=0$. Hence, we assume w.l.o.g. $x\geq pos_{j}$. Furthermore let $\bar{x}:=x-pos_{j}$. We simplify the exposition and show that $\tt{F(x)_{j}}\leq\frac{1}{T}$ by making our arguments on $\bar{x}$. Note that in order for $\tt{SPRAY(\log T-1,\log T,1)_{j}}$ to land on position $x$, the following must hold:

[TABLE]

where for each $i$, $a_{i}$ is chosen independently from $[0,\log T]$. Thus, we are interested in the probability that the sum of the different $a_{i}$, each chosen independently from $[0,\log T]$ yield Equation (1). Instead of calculating this probability directly we will give an upper bound for it based on a simple argument with respect to the parity of the bits in the binary expansion of $\bar{x}$.

The idea is to give the probability that each randomly chosen $a_{i}$, starting with $i=0$, contributes to the correct parity of the binary expansion of $\bar{x}$ moving from left to right. This is possible because of the shifting factor of $2^{i}$ for each $a_{i}$. Certainly, all randomly chosen $a_{i}$ that satisfy Equation (1) must satisfy this property, but not the other way around. Therefore, this probability yields an upper bound for $\tt{F(x)_{j}}$. We show this more precisely as follows.

Let $\bar{x}(l)$ denote the $l$-th least significant bit of $\bar{x}$, and for each $i$, let $a_{i}(l)$ denote the $l$-th least significant bit of $a_{i}$. In order to ensure the correct parity of the binary expansion of $\bar{x}$ moving from left to right by sequentially choosing $a_{i}$ in $[0,\log T]$ starting with $i=0$, it is easy to see that $a_{0}(0)=\bar{x}(0)$ must hold. More generally, because of the shifting factor of $2^{k}$ for each $a_{k}$, the following equation (whose left hand side represents bit addition)

[TABLE]

must hold for all $1\leq k\leq\log T-1$, where $c$ is determined by the previous choice of $a_{0},a_{1},\ldots a_{k-1}$.

We will derive the desired upper bound by considering the probability of sequentially and randomly picking $a_{i}$ that respect the parity of the binary expansion of $\bar{x}$ as explained above, starting with $a_{0}$, then continuing with $a_{1}$ and so on until $a_{\log T-1}$. We say that a chosen $a_{k}$ is a $\tt{match}$, if it respects the parity of the binary expansion of $\bar{x}$ as in Equation (2). Thus we are interested in the probability on the right hand side of the following inequality:

[TABLE]

where $A_{i-i}$ is the event where all $a_{k}$ such that $0\leq k\leq i-1$ are a $\tt{match}$. First we will explicitly derive the right hand side of Inequality (3) then we will give a simple argument as to why the inequality holds.

First of all, it is clear that $\tt{Pr}[a_{0}\text{ is a }\tt{match}]=\frac{1}{2}$. This is because we assumed $\log T$ is odd and exactly half the numbers in $[0,\log T]$ are even or odd. Furthermore, this can be readily generalized for $\tt{Pr}[a_{i}\text{ is a }\tt{match}|\tt{A_{i-1}}]$, where $1\leq i\leq\log T-1$. Given $A_{i-1}$, i.e., $a_{0},a_{1},\ldots a_{i-1}$ that have respected the parity of $\bar{x}$ as above, exactly half the possible choices in $[0,\log T]$ will contribute an $a_{i}$ such $a_{k}(0)$ satisfies Equation (2), where $k=i$. Hence $\tt{Pr}[a_{i}\text{ is a }\tt{match}|\tt{A_{i-1}}]=\frac{1}{2}$, for each $1\leq i\leq\log T-1$. Thus,

[TABLE]

Consider choosing $a_{k}$ sequentially as before, but this time the chosen $a_{k}$ in addition to satisfying Equation (2), must also represent an actual possible part of a $\tt{SPRAY}$ path that satisfies Equation (1). We say that a chosen $a_{k}$ is an $\tt{exact}$ $\tt{match}$ if this is the case. Then, it follows that

[TABLE]

where $A_{i-i}$ is the event where all $a_{k}$ such that $0\leq k\leq i-1$ are an $\tt{exact}$ $\tt{match}$. Hence, Inequality (3) holds, and the desired result follows from Equation (4). ∎

Theorem 2**.**

For each $\tt{SPRAY(\log T-1,\log T,1)_{j}}$, for any list $j$ in the maximum level of a perfect skip graph, the position of the node on which the operation lands is at most $\frac{T}{2}+\log T\cdot(T-1)-1$.

Proof.

Consider a perfect skip graph such that $N\geq\frac{T}{2}+T\log T$. We show that any $\tt{SPRAY(\log T-1,\log T,1)_{j}}$ operation can reach from its starting position is $\frac{T}{2}+\log T\cdot(T-1)T$ units forward to the right. For any list $j$ in the maximum level of a perfect skip graph, if the path chosen by a $\tt{SPRAY(\log T-1,\log T,1)_{j}}$ operation moves forward to the right by $\log T$ nodes on the corresponding lists in every possible level, we arrive at a total of $\sum_{i=0}^{\log T-1}2^{i}\log T=\log T\sum_{i=0}^{\log T-1}2^{i}=\log T\cdot(T-1)$ units forward to the right.

By Proposition 3, if we label the positions of the heads of lists in the maximum level moving from left to right in order of appearance, we arrive at $pos_{\log T-1}^{0},pos_{\log T-1}^{1},\ldots pos_{\log T-1}^{2^{\log T-1}-1}$, where $pos_{\log T-1}^{i}=i$, for all $0\leq i\leq 2^{\log T-1}-1$. Consider list $k$ whose head is the node in position $pos_{\log T-1}^{2^{\log T-1}-1}=2^{\log T-1}-1=\frac{T}{2}-1$. Then, by the argument in the previous paragraph, there is a $\tt{SPRAY(\log T-1,\log T,1)_{k}}$ operation that lands in position $\frac{T}{2}+\log T\cdot(T-1)-1$. ∎

We denote our protocol using the $\tt{SPRAY(\log T-1,\log T,1)_{j}}$ operations on perfect skip graphs as $\tt{SPRAY\_SG}$, and on perfect skip lists as $\tt{SPRAY\_SL}$. Finally we denote our deterministic, mark-along protocol on perfect skip graphs as $\tt{SGMARK}$. The protocol is shown in Alg. 6, below.

We conclude that any $\tt{SPRAY}$ operation in $\tt{SPRAY\_SG}$, using the same technique from [3], satisfies the same probability bounds as any $\tt{SPRAY}$ operation with the same parameters in $\tt{SPRAY\_SL}$. The difference is that the range of furthest reaching $\tt{SPRAY}$ operation is greater in $\tt{SPRAY\_SG}$ than $\tt{SPRAY\_SL}$. In particular for $\tt{SPRAY}$ operations with parameters as in Proposition 2 the range for $\tt{SPRAY\_SG}$ is $\frac{T}{2}+T\cdot\log T$, whereas the range for $\tt{SPRAY\_SL}$ is $T\cdot\log T$. The range of $\tt{SGMARK}$ is exactly $T$. In the next section, our approach will consist on defining a skip list spray that disperses threads among the same range as $\tt{SGMARK}$, and then indicate that contention is expected to be smaller in a skip graph due to structural features of the skip graph itself.

5.2 Skip List Sprays over $T$ Elements

Definition 3**.**

A skip list is perfect if the absolute value of the difference in the positions of any two consecutive nodes on level $i$ is $2^{i}$, and every list on level $i$ contains at least $\frac{T}{2^{i}}$ nodes, for all $0\leq i\leq\log T-1$.

The operation $\tt{SPRAY(H,L,D)}$ defines a random walk starting at height $\tt{H}$, i.e., at the head of the list at level $\tt{H}$ of the skip list. The walk continues forward to the right a uniformly random number of nodes chosen from $\tt{[0,L]}$ then moves down the skip list $\tt{D}$ levels. This is repeated until we reach the bottom list and (possibly) walk forward to the right one last time. Thus the walk ends in position $x$ of the bottom list.

Definition 4**.**

Let $x$ be the position of any node in a perfect skip list. Then $\tt{F_{p}(x)}$ denotes the probability that, for some fixed $\tt{H}$, $\tt{L}$, and $\tt{D}$, $\tt{SPRAY(H,L,D)}$ lands at position $x$ in the bottom list.

Proposition 1**.**

Let $x$ be the position of any of the first $T$ nodes of a perfect skip list. There is a $\tt{SPRAY(\log T-1,1,1)}$ that lands at position $x$ in the bottom list.

Proof.

The furthest $\tt{SPRAY}$ operation moves forward to the right a total of $T-1$ units as follows, $\sum_{i=0}^{\log T-1}2^{i}=2^{\log T}-1=T-1$. Hence we reach the $T$-th node. Suppose there is some $\tt{SPRAY}$ operation that reaches a node whose position is $k$, where $0<k<T-1$. Consider the following two cases:

• •

The path determined by the given $\tt{SPRAY}$ operation consists of a final step forward. By ignoring the final step forward we arrive at a path that reaches position $k-1$.

• •

The path determined by the given $\tt{SPRAY}$ operation does not consist of a final step forward. Consider the smallest level $i$ where the path turns left (moving from bottom to top). The preceding node $j$ on the list in level $i$ is in position $k-2^{i}$. Moving a level down from $j$ then forward to the right every possible level we cover a total of $\sum_{l=0}^{i-1}2^{n}=2^{i}-1$ units horizontally and reach position $k-1$.

∎

Corollary 1**.**

Fix $\tt{H}=\log T-1$, $\tt{L}=1$, and $\tt{D}=1$. Let $x$ be the position of any of the first $T$ nodes of a perfect skip list. Then $\tt{F_{p}(x)}=\frac{1}{\tt{T}}.$

Proof.

From Proposition 1 we know that there exist some $\tt{SPRAY(\log T-1,1,1)}$ operation that reaches any of the first $T$ nodes, and from its proof we see that no $\tt{SPRAY}$ operation can reach beyond the first $T$ nodes. Given any position $x$, where $0\leq x\leq T-1$, next we show that the $\tt{SPRAY}$ operation that lands on position $x$ is path-wise unique.

Fix any arbitrary $x$, where $0\leq x\leq T-1$, and consider some $\tt{SPRAY(\log T-1,1,1)}$ operation that lands on the node in position $x$. Suppose there exists another path-wise distinct $\tt{SPRAY}$ operation that lands on the node in position $x$, which we denote by $\tt{SPRAY}_{2}$. Consider the largest level $i$ and node $j$ where the paths of the two path-wise distinct $\tt{SPRAY}$ operations differ. Let the position of node $j$ be $k$. W.l.o.g. assume the path which belongs to the first $\tt{SPRAY}$ operation moves forward to the right from node $j$ on level $i$ before descending a level. This ensures that $k+2^{i}\leq x$. The path induced by the $\tt{SPRAY}_{2}$ operation does not move forward to the right and instead directly descends a level from node $j$. This implies the path can move forward to the right from position $k$ at most $\sum_{n=0}^{i-1}2^{n}=2^{i}-1$. Thus the furthest position a path induced by $\tt{SPRAY}_{2}$ can reach is $k+2^{i}-1<x$, which is a contradiction.

Since there is only one unique path that reaches each $x$, at each level $i$, where $0\leq i\leq\log T-1$, the probability that any given $\tt{SPRAY}$ generates the correct portion of the path at level $i$ is exactly $1/2$. Since this probability is independently uniform at each level $i$, we arrive at $\tt{F_{p}(x)}=\prod_{i=0}^{\log T-1}\frac{1}{2}=\frac{1}{2^{\log T}}=\frac{1}{\tt{T}}.$ ∎

Let $X$ denote the number of $\tt{SPRAY}$ operations in a perfect skip list until every position $x$, where $0\leq x\leq T-1$, is reached. We are interested in the expected number of $\tt{SPRAY}$ operations which ensure that every position $x$ is reached at least once. To arrive at the expected number of $\tt{SPRAY}$ operations we show our question of interest is simply the well-known Coupon Collector’s Problem [15]. Thus the desired result is proportional to $T\log T$.

Now that we defined a skip list spray that disperses threads among a segment of size $T$, we show that the expected number of operations to mark all elements in that segment is $\Theta(T\log T)$.

5.3 Number of Successful CAS Operations when Spraying on Skip Lists

Theorem 3**.**

$\operatorname*{\mathbb{E}}[X]$* is in $\Theta(T\log T)$.*

Proof.

Let $X_{i}$ denote the number of $\tt{SPRAY}$ operations performed while exactly $i-1$ positions in the bottom list have been already reached. Then $X=\sum_{i=1}^{T}X_{i}$ holds. Thus, each $X_{i}$ is a geometric random variable. If exactly $i-1$ positions have already been reached by previous $\tt{SPRAY}$ operations then the probability that next $\tt{SPRAY}$ operation reaches a different position is simply $p_{i}=1-\frac{i-1}{T}$. This is exactly the Coupon Collector’s Problem. We outline the analysis for completion and clarity as follows:

[TABLE]

where $H(T)$ is the $T$-th harmonic number. Using elementary calculus one can show that $H(T)=\ln T+\Theta(1)$ [33, 33] and hence $T\cdot H(T)=T\ln T+\Theta(T)$. Thus it follows that $\operatorname*{\mathbb{E}}[X]$ is in $\Theta(T\log T)$. ∎

Corollary 2**.**

Let $T\geq 4$. Then $\operatorname*{\mathbb{E}}[X]\geq 2T$.

Proof.

We can use well-known elementary techniques to bound $H(T)$ as follows:

[TABLE]

Then from Theorem 3 we have that $\operatorname*{\mathbb{E}}[X]=T\cdot H(T)\geq T\left(1+\frac{1}{2}\log T\right)$, which gives the desired result for all $T\geq 4$. ∎

We now characterize how a custom relaxed priority queue algorithm, designed precisely in order to exploit the central structural features of the skip graph, can remove elements from a range of $T$ elements with proven contention being exactly 2 for any number of threads $T$.

5.4 Number of Successful CAS Operations when Spraying on Skip Graphs with Our Algorithm

Definition 5**.**

Let $T=2^{n}$, where $n\geq 1$. A perfect skip graph is minimal if the number of nodes in the bottom list is exactly $T$.

Thus each $n\geq 1$ determines a unique minimal skip graph (up to permutation of lists in each level) which we denote be $PSG_{\tt{min}}(n)$. Given $PSG_{\tt{min}}(n)$, we will show that it contains all smaller perfect minimal skip graphs.

Definition 6**.**

Consider $PSG_{\tt{min}}(n)$ and $PSG_{\tt{min}}(m)$, where $n>m\geq 1$. Then $PSG_{\tt{min}}(n)$ contains $PSG_{\tt{min}}(m)$, if by ignoring consecutive levels and consecutive nodes of $PSG_{\tt{min}}(n)$ we arrive at $PSG_{\tt{min}}(m)$ (up to permutation of lists in each level).

Proposition 2**.**

For all $n\geq 2$, $PSG_{\tt{min}}(n)$ contains all smaller minimal perfect skip graphs.

Proof.

For $n=1$ by definition the minimal perfect skip graph is a list with $2$ nodes. Consider a list with $4$ nodes (2 copies of $PSG_{\tt{min}}(1)$). Partitioning this list into two other lists with consecutive node positions $0,2$ and $1,3$ we arrive at $PSG_{\tt{min}}(2)$. Let $n=3$. We will construct $PSG_{\tt{min}}(3)$ from $PSG_{\tt{min}}(2)$ in the following way. We glue two copies of $PSG_{\tt{min}}(2)$ together so that the height of the new structure is the same as $PSG_{\tt{min}}(2)$ but the bottom list has length $8$. It is straightforward to see these are the first $2$ levels of $PSG_{\tt{min}}(3)$. Thus we arrive at $PSG_{\tt{min}}(3)$ by adding its maximum level.

Suppose it holds for all $n\leq k$, for some $k>3$. Consider $PSG_{\tt{min}}(k+1)$. Ignoring the maximum level, we see by translational symmetry that the remaining structure consists of two glued copies of $PSG_{\tt{min}}(k)$. By the induction hypothesis $PSG_{\tt{min}}(k)$ contains all other smaller minimal perfect skip graphs. ∎

Let $T=2^{n}$ for $n\geq 1$. Then our partition scheme ensures there are exactly two threads acting on the heads of each list of the maximum level of the perfect skip graph at the beginning of $\tt{SGMARK}$. In the following arguments we assume that the process of marking a node by one of the threads on level $n-1$ then having the other thread descend to a list on level $n-2$ occurs simultaneously for all $2^{n-1}$ lists $k$ of level $n-1$. More generally, whenever threads are on level $i$, the ones which fail to mark nodes will simultaneously move down a level. Furthermore we assume, that if two threads traversing the same list where the nearest unmarked node $j$ is the same for both, then the threads reach $j$ simultaneously. Suppose two threads are acting on every list $k$ of some fixed level $i$ of a perfect skip graph, where $1\leq i\leq n-1$, such that for every list $k$ the nearest unmarked node $j$ is the same for both threads. Then we will assume all threads will simultaneously reach their respective contested nodes.

Under these assumptions, we can model $\tt{SGMARK}$ as a game with $n$ rounds. The last round is a special case where the surviving thread will walk forward to the right one last time instead of descending. At the beginning of a regular round all surviving threads up to that round are on level $i$, where $0\leq i\leq n-2$, whereas at the end of the round some threads have moved down a level and have traversed to the right. We will see that it suffices to consider our protocol on minimal perfect skip graphs. First, we will need the following definitions, which are well-defined by Proposition 2.

Definition 7**.**

For all $n\geq 2$, we arrive at the right hand side copy of $PSG_{\tt{min}}(n-1)$ in $PSG_{\tt{min}}(n)$, by ignoring level $n-1$ of $PSG_{\tt{min}}(n)$ and the first $2^{n-1}$ consecutive nodes of the bottom list in $PSG_{\tt{min}}(n)$.

Definition 8**.**

For all $n\geq 2$, we arrive at the left hand side copy of $PSG_{\tt{min}}(n-1)$ in $PSG_{\tt{min}}(n)$ via translational symmetry by shifting the right hand side copy of $PSG_{\tt{min}}(n-1)$ in $PSG_{\tt{min}}(n)$ to the left $2^{n-1}$ positions.

Proposition 3**.**

Let $T=2^{n}$, where $n\geq 2$. Consider any level $i$ of $PSG_{\tt{min}}(n)$, where $0\leq i\leq n-1$. Consider nodes from left to right in order of appearance and let $pos_{i}^{0},pos_{i}^{1},\ldots pos_{i}^{2^{i}-1}$ denote the positions of the heads of the respective $2^{i}$ list in level $i$. Then $pos_{i}^{j}=j$, for all $0\leq j\leq 2^{i}-1$.

Proof.

This is trivially true for $n=2$ by inspection. Suppose it holds for some integer $k>2$. Consider $PSG_{\tt{min}}(k+1)$. If we ignore level $k$ of $PSG_{\tt{min}}(k+1)$, we are left with the left hand side and right hand side copy of $PSG_{\tt{min}}(k)$ in $PSG_{\tt{min}}(k+1)$. Therefore, for all levels $i$ such that $0\leq i\leq k-1$, the statement holds by the induction hypothesis. By symmetry, the maximum level of $PSG_{\tt{min}}(k+1)$ is partitioned into two parts, one part of the maximum level located above the left hand side copy of $PSG_{\tt{min}}(k)$ in $PSG_{\tt{min}}(k+1)$, and the other above the right hand side copy of $PSG_{\tt{min}}(k)$ in $PSG_{\tt{min}}(k+1)$. Since the maximum level of any minimal perfect skip graph contains lists with only two nodes, the portion of each list in the maximal level that is above the left hand side copy of $PSG_{\tt{min}}(k)$ in $PSG_{\tt{min}}(k+1)$ contains only one node. These are the $2^{k}$ heads of the lists in level $k$ of $PSG_{\tt{min}}(k+1)$, and since the maximum level is a partition of the nodes on the bottom list, after possibly reordering they have positions $0,1,\ldots 2^{k}-1$. ∎

Proposition 4**.**

For any $n\geq 2$ and $PSG_{\tt{min}}(n)$, at the end of the first round of $\tt{SGMARK}$ on $PSG_{\tt{min}}(n)$, we have $2$ threads acting on the heads of the lists of the maximum level of the right hand side copy of $PSG_{\tt{min}}(n-1)$ in $PSG_{\tt{min}}(n)$.

Proof.

Fix $n\geq 2$, where $T=2^{n}$. According to $\tt{SGMARK}$, at the beginning of the first round there are exactly two threads acting on the heads of each of the lists in level $n-1$. By Proposition 3, positions $pos_{{n-1}}^{0},pos_{{n-1}}^{1},\ldots pos_{{n-1}}^{2^{n-1}-1}$, are marked by $2^{n-1}$ threads. The remaining $2^{n-1}$ threads move simultaneously down to level $n-2$. Each list in level $n-2$ is partitioned into two lists in level $n-1$ (first two nodes in each level $n-2$ become heads of lists in level $n-1$), and it follows that for each list $k$ of level $n-2$, we have exactly two threads acting on list $k$, one for each of the first two consecutive nodes on that particular list. There are now a total of $2^{n-2}$ threads positions at the heads of all list $k$ in level $n-2$. By Proposition 3 it follows that the threads are in positions $pos_{n-2}^{0},pos_{n-2}^{1},\ldots pos_{n-2}^{2^{n-2}-1}$. Since there is also a thread on the second node of every list $k$ on level $n-2$, for every two threads on any such list $k$ the nearest unmarked node is the next consecutive one. Counting from the heads of the lists on level $n-2$ the third consecutive node will be $2^{n-1}$ positions away. This implies, that at the end of the first round we will have two threads on each of the positions $pos_{n-2}^{2^{n-1}},pos_{n-2}^{2^{n-1}+1},\ldots pos_{n-2}^{(2^{n-1}+2^{n-2}-1)}$. These are just the heads of the lists of the maximum level of the right hand side copy of $PSG_{\tt{min}}(n-1)$ in $PSG_{\tt{min}}(n)$. ∎

Corollary 3**.**

Let $n\geq 2$. The end of the first round of $\tt{SGMARK}$ on $PSG_{\tt{min}}(n)$ is equivalent to the start of a first round of $\tt{SGMARK}$ on the right hand side copy of $PSG_{\tt{min}}(n-1)$ in $PSG_{\tt{min}}(n)$.

Proof.

Follows directly from Proposition 4. ∎

Theorem 4**.**

Let $n\geq 2$. $\tt{SGMARK}$ on $PSG_{\tt{min}}(n)$ ensures that exactly $T=2^{n}$ nodes are marked. Furthermore, 2 threads contend for each of the first $T-1$ consecutive nodes, and 1 thread tries to CAS (logically delete) the last node.

Proof.

Let $n=2$. This means there are $2$ threads acting on each of the nodes in position [math] and $1$ on the second level of $PSG_{\tt{min}}(2)$. According to $\tt{SGMARK}$, one thread each will mark nodes in positions [math] and $1$ respectively, followed by the other two threads that will descend to the bottom list. Then, both threads will move to the right simultaneously to the node in position $2$, and one of the threads will succeed in marking the node in position $2$. Finally the last thread will move to the right and mark the last node. Thus, two threads contended for each node in positions $0,1$ and $2$, and there was no contention in the last node, since at most 1 thread can try to CAS (logically delete) the last node.

Suppose the claim holds for some $k>2$. Consider the first round of $\tt{SGMARK}$ on $PSG_{\tt{min}}(k+1)$. Following the proof of Proposition 4, we see that the first $2^{k}$ nodes are marked at the start of the first round, and there are two threads contending for each of the $2^{k}$ nodes that are marked. By Corollary 3 we see that the end of the first round on $PSG_{\tt{min}}(k+1)$ is the start of the first round on the right hand side copy of $PSG_{\tt{min}}(k)$ in $PSG_{\tt{min}}(k+1)$. Therefore by the induction hypothesis $\tt{SGMARK}$ will mark exactly $2^{k}+2^{k}=T^{k+1}$ nodes. Furthermore 2 threads contend for the first $T^{k+1}-1$ consecutive nodes, and 1 thread tries to CAS (logically delete) the last node. ∎

6 Evaluation

We conducted experiments in a system with 2 Intel Xeon Platinum 8275CL CPUs, each with 24 cores running at 3.0GHz (96 hardware threads total). The system has 192GB of memory and two NUMA nodes. The tool numactl --hardware reports intra-node distances of 10 and inter-node distances of 21. The system runs Ubuntu Linux 18.04 LTS with kernel 4.15.0. We use g++ -std=c++11 -O3 -m64 -fno-strict-aliasing to compile tests.

Experiment setup. We report the total number of operations per millisecond achieved in trials having from 2 up to 96 threads. Each trial is an average of 5 runs of 10s each, and follows exactly the testing procedure of Synchrobench [19] with the flag -f 1. This flag indicates that the testing procedure tries to match each trial’s requested percent of update operations (inserted and remove) as much as possible, and that only successful inserts or removals count as update operations. The testing procedure, as well as random number generation, are identical to Synchrobench. We run a read-heavy (RH) load, with a requested 20% of update operations, a write-heavy (WH) load, with a requested 50% of update operations, and a priority queue (PQ) load, with 50% of insertions and 50% of removals, all distributed uniformly at random across all threads (except for our load-balancing tests). If X% of operations correspond to successful updates in a given experiment, we say we had X% of effective updates, and we report that percentage in each associated graphic caption. Our experiments are defined to be high contention (HC) when the key space is $2^{8}$, medium contention (MC) when it is $2^{11}$, and low contention (LC) when it is $2^{17}$. The structures are preloaded with 20% of their maximum capacity before any measurements, except for the LC tests, which are preloaded with 2.5%. LC tests and analysis are presented in Appendix. D; here we will focus on HC and MC tests. Threads are pinned to each CPU, and we fill a socket before adding threads to another socket. We allocate memory with libnuma, in chunks capable of holding $2^{20}$ objects, in order to amortize the expensive cost of numa_alloc_local().

Membership Vectors. Our membership vectors are generated so that threads pinned to closer hardware threads in the system have their associated skip lists sharing more levels. We obtain data from /proc/cpuinfo on Linux, then renumber threads so the larger the absolute difference between thread identifiers $1\ldots T$, the larger the physical distance between their associated CPUs. We consider NUMA domains, core collocation, and hardware-thread collocation in order to access distance and define our membership vectors.

1 - Performance results. Figures 4 and 4 show write-heavy (WH) results for the HC and MC contention scenarios. Low-contention results (LC) are presented in Appendix D, and read-heavy (RH) results are presented in Appendix E. In our graphs, layered_map_{sg,ssg} refers to using C++ std::map in conjunction with the hash [4] as local structures, respectively over regular or sparse skip graphs (p. 2) as shared structures; lazy_layered_sg is the lazy variant of layered_map_sg; rotating is [13], nohotspot is [10], and numask is [11] as found in Synchrobench’s GitHub (mid August 2019). For the purpose of isolating individual design components in our analysis, we also developed as control: a locked skip list; a concurrent skip list with the same codebase and practices as our skip graph code, including our relink optimization (p. 4); a skip graph without layering; and finally layered C++ maps (i) over a linked list (layered_map_ll) and (ii) over a skip list (layered_map_sl). The former is essentially a layered_map_sg with maximum level 0, and the latter a layered_map_ssg with a single constituent skip list (hence, with no opportunity to implement our partitioning scheme). Non-layered skip lists or skip graphs have maximum level $x$ if the test’s key space is of size $2^{x}$, and layered versions follow our partitioning scheme definitions (p. 1).

With a small key space (HC-WH), layered_map_ll performs better than layered_map_sg and layered_map_sl, but the performance degrades quickly as the key space gets bigger (MC-WH, Fig. 4; LC-WH, Fig. 11, Appendix D). With bigger key spaces, more elements need to be traversed in the shared structure upon searches. We could be tempted to say that the multilevel shared structure in layered_map_sg is the reason it performs better in MC-WH, but note that layered_map_sl performs worse than layered_map_ll in the same case MC-WH. The reason why layered_map_sg performs better in the MC-WH scenario seems to be, therefore, related to the partitioning scheme in the shared structure (the skip graph). Further, in the same MC-WH scenario, we note a clear performance separation between layered_map_ssg and layered_map_sl after 16 threads. The existence of multiple, overlapping of skip lists, employing a partitioning scheme across threads, is the essential difference between these two approaches.

As far as the lazy implementation performance, we see it as a combination of (i) the effectiveness of our partition scheme for increasing NUMA locality and reducing contention (discussed above and verified below, in item #2); (ii) the commission policy to unlink invalid, marked nodes (isolated right below); and (iii) the fact that with smaller key spaces, threads will more commonly find unmarked nodes through their local hashtable, which performs much better compared to the std::map local structure. We show a lazy_layered_map_sgNA where we make the commission period zero, as control. Under HC-WH, [13] performs well, and our control implementation is comparable to [11, 10]. Under MC-WH, [10] performs well, and our control implementation is comparable to [11, 13]. In any case, we confirm our expectation that naive skip graphs scale poorly, because while in a skip list the expected number of levels of each node is 2, in a skip graph it is always the maximum. Further, on Tbl 2, we see how layered_map_sg, without any commission period, requires a lot more CASes per operation than other structures. With that in mind, and considering our indications that the partitioning scheme works, we have first to make sure that skip graphs become viable with techniques such as lazy insertions/removals, the commission period, and our relink optimizations mentioned in p. 4.

2 - NUMA locality and contention reduction. We verify that our partitioning mechanism promotes better NUMA locality and reduced contention below. Figures 6 and 6 show heatmaps where coordinates $(i,j)$ indicate the distribution of CAS instructions per operation performed by thread $i$ into a node allocated by thread $j$, instrumented manually on node access functions on the 96-thread MC-WH scenario. The memory access pattern shows that the larger the distance between thread IDs (which we adjusted to match the NUMA distance), the smaller the number of memory accesses. Comparing the lazy skip graph and a skip list (which serves as our control, as it has been implemented using the same codebase and practices), the heatmaps indicate a dramatic increase in CAS NUMA locality. We provide graphics for other structures (non-lazy skip graph, non-lazy sparse skip graph) in Appendix F. Also related to locality, we expect fewer cache misses due to our partitioning mechanism, an expectation that is confirmed on Tbl. 1.

Regarding contention, Tbl. 2 shows additional metrics collected via manual code instrumentation, on the 96-thread HC-WH scenario. Both our heatmaps and Tbl 2 do not count CAS/read/write operations performed over an inserting node, otherwise locality would be artificially inflated with no-contention operations that are inherently local, as threads have to initialize their allocated nodes. Any CAS operation metric presented is a maintenance CAS: an operation required to link, unlink, or cleanup nodes.

Note that although lazy_layered_map_sg performs slightly more reads per operation than skip lists, it performs a 68% less remote CASes per operation (maintenance CASes). The CAS success rate is substantially higher (99% in lazy_layered_map_sg vs. 88.3% in the skip list). Both the increase in NUMA locality, discussed before, and the contention reduction, just discussed, are attributed to our partitioning scheme, designed precisely with those goals (p. 1).

3 - Relaxed priority queues. Figure 13 tests multiple implementations for relaxed priority queues using skip graphs. The spray implementation consists on the application of the spraying technique of [3] over skip graphs; the sg_spray implementation is our custom protocol that traverses the skip graph deterministically, marking elements along this traversal (Alg. 6, Appendix 5). For both approaches, we also show lazy versions (spray_lazy and sg_spray_lazy). We also have a control skip list (implemented using the same codebase and practices) where we perform spray operations as in [3].

Lazy versions are expected to perform faster for similar reasons they perform better in maps, although, for relaxed priority queues, we cannot make guarantees about their degree of relaxation. The reason is that upper-level lists are substantially more sparse in our lazy implementations, and elements are added to those lists by demand, something which we cannot (at this point) reasonably model. Now focusing on the non-lazy versions, we note that spray scales better than sg_spray. Although Theorems 3 and 4 indicate that sg_spray is subject to smaller contention, we also show there that the range of spray is slightly larger. Fig. 8 shows an experiment similar to the one in [3], where we perform traversals and only note which nodes would be marked, without actually marking any element. The experiment shows that sg_spray is indeed less relaxed than spray. In conjunction, Figures 8 and 8 essentially exhibit a tradeoff between priority queue relaxation and scalability.

4 - Load balancing. In order to evaluate load balancing, we consider two experiments. When only thread $T_{0}$ inserts, and all others perform removals and contains operations in an MC-WH experiment, Figure 10 still shows that the sizes of the local structures are similar. In that figure, the X-axis represent 100 discrete time points, varying from 0-10s, the Y-axis represents 8 different threads, and the color indicates the local structure size (not counting marked elements). A different experiment considers the scenario where $1/2$ of the threads insert only on the 0-1023 range of a 2048 keyspace, and $1/2$ of the threads insert only on the 1024-2047 range of the keyspace. Figure 10 shows that the key distribution of two threads that belong to two different groups are spread throughout the whole element space. In the figure, the X-axis represents possible keys, the Y-axis represents 10 discrete time points, one per second, and the color represents whether a particular key belongs to thread 1 or 2 in their local structure.

7 Conclusion

We presented a data partitioning technique based on using skip graphs that shows quantitative and qualitative improvements in NUMA locality, as well as reduced contention. We build on previous techniques of thread-local indexing and laziness, and, at a high level, our design consists of a partitioned skip graph, well-integrated with thread-local sequential maps, operating without contention.

As a proof-of-concept, we implemented map and relaxed priority queue ADTs using our technique. Maps were conceived using lazy and non-lazy approaches to insertions and removals. Remote memory accesses were not only reduced in number, but the larger the NUMA distance between threads, the larger the reduction was, demonstrating a qualitative feature besides a quantitative one. We provide an optional load-balancing mechanism, based on donating inserted nodes across thread-local indexes of all threads, coordinated by a single background thread.

For relaxed priority queues, we consider two alternative implementations of relaxed priority queues: (a) using “spraying”, a well-known random-walk technique usually performed over skip lists, but now performed over skip graphs; and (b) a custom protocol that traverses the skip graph deterministically, marking elements along this traversal. We provide formal arguments indicating that the first approach is slightly more relaxed, that is, that the span of removed keys is larger, while the second approach has smaller contention. Experimental results indicate that the approach based on spraying performs better on skip graphs, yet both seem to scale appropriately.

Appendix A Contains

In algorithm contains() (Alg. 7), if the thread finds an unmarked, shared node, it will test if this node is unmarked and valid (line 4). If so, a successful contains is linearized right at that time (C-i). If not, we call SG::contains() (Alg. 8), which will complete the procedure.

The algorithm SG::contains() (Alg. 8) starts by calling getStart() (Alg. 4), which finds the closest preceding, unmarked shared node pointed by the local structure (line 2). We call this node currentStart. We then perform a search in line 4, starting from currentStart, using our procedure retireSearch() (Alg. 9). (C-ii) If an unmarked shared node with the goal key is not found, we linearize a failed contains operation at the time we found the element succeeding that key in the bottom level. (C-iii) If an unmarked shared node with the goal key is found: (C-iii-a) if we verify the node is unmarked and valid (test of line 6), we linearize a successful contains at that time. (C-iii-b) Otherwise, we linearize the failed contains at the earliest among the time we failed to verify the node was unmarked and valid (line 6), or right after the time the node became unmarked.

We now present our second search procedure, retireSearch() (Alg. 9). This algorithm is employed by contains and remove operations to search for unmarked shared nodes with a goal key, starting from currentStart. The algorithm is a simplification of lazyRelinkSearch() (Alg. 5), as it does not keep track of predecessors or successors as the structure is traversed.

Appendix B Extra Insertion Algorithms

The algorithm updateStart() (Alg. 10) finds an unmarked shared node pointed by the local structure that closest precedes the key associated with currentStart.

Starting from currentStart, it traverses the local structure backwards (line 10) for as long as the shared nodes pointed by the local structure are found marked. Note that updateStart() is essentially a simplified version of getStart() that does not finish insertions lazily, and ignores nodes that are not fully inserted as it traverses the local structure backwards.

The algorithm finishInsert() (Alg. 11) links elements at levels $1\ldots\mathrm{MaxLevel}$ in the thread’s associated skip list. The procedure uses at line 4 the lazyRelinkSearch() procedure to locate, at all levels $0\ldots\mathrm{MaxLevel}$: (A) which nodes should precede toInsert (referenced in predecessors); (B) which nodes should succeed toInsert (referenced in successors); and (C) nodes referenced in middle such that middle[i] contains predecessors[i].getNext(i) right after the time each predecessor predecessor[i] was identified. Between predecessors[i] and successors[i] we have a sequence of nodes with their level-$i$ references marked. We hope that in the CAS of line 13, we replace that sequence of nodes with toInsert. If the CAS fails, we update currentStart with updateStart(), and retry the search. If at any moment, we cannot locate an unmarked toInsert, this node has been marked while this procedure was taking place, and we indicate our failure to build all levels in line 5.

Appendix C Remove

Algorithms 12, 13, and 14 show the remove operation for key. In remove() (Alg. 12), if the thread finds a reference to a shared node with the goal key, it calls removeHelper() (Alg. 13). This call returns true only if: (R-i) We found an unmarked, invalid node, so we linearize a failed removal right at that time. There cannot exist another unmarked, valid node in this case, which justifies our linearizability. (R-ii) We successfully unset the valid bit of an unmarked, valid node, so we linearize the successful removal right at that time as well. If removeHelper() returned false, the shared node previously found is marked, so (i) we clean the thread’s local structure (Alg. 13, lines 10 and 11); and (ii) we call lazyRemove() (Alg. 14), which will complete the removal.

The algorithm lazyRemove() (Alg. 14) starts by calling getStart() (Alg. 4), which finds the closest preceding, unmarked shared node pointed by the local structure (line 2). We call this node currentStart. We then perform a search in line 5, starting from currentStart and: (R-iii) If an unmarked shared node with the goal key is found (call it found), then a call to removeHelper() (line 8) will define our linearization, just like our previous discussion of Alg. 12. If that call returns false, found became marked, so we retry the search. (R-iv) No unmarked node with the goal key has been found, so in that case we linearize a failed removal at the time we found the element succeeding that key in the bottom level.

C.1 Retiring Nodes

The algorithm checkRetire() (Alg. 15) is performed as we search for elements on behalf of insert() or remove(). The procedure returns true only if a node is unmarked and its commission period has expired, indicating that the node a candidate for physical removal. A subsequent call to retire() will try to start the physical removal process over a node, if the latter is found invalid.

The algorithm retire() (Alg. 16) tries to atomically invalidate a node’s bottom level reference, while guaranteeing that this reference was invalid throughout the process (line 1). The CAS performed at such line can fail because (i) a node’s reference has been changed; or (ii) because the node became just before the CAS. In either situation, our CAS will fail and we simply return false. In an active node, particularly under case (ii), we would prefer to keep the node unmarked, so returning false has an operational advantage.

Appendix D More Experimental Results: LC tests

We believe the LC-WH scenario is very meaningful from an analytic standpoint. First, it shows that our layered approaches take full advantage of a low contention setting, matching the performance of a locked skip list (expected to work very well in such scenarios).

We attribute this to (i) highly effective local structures, with no overhead of atomic operations or locks; (ii) to the fact that new nodes need to be inserted in only 2 levels on expectation, instead of a fixed 2-6, depending on the number of threads, as prescribed by our partitioning policy; (iii) to a better cache efficiency, documented in Tbl. 1; and (iv) to better NUMA locality (verified in item #2, below). The performance of layered_map_ssg in fact reveals an interesting tradeoff: although less shared nodes reach the topmost level and get included in the local structures, thus making the starting point of shared operations not as “close” as in the non-sparse version, the number of CAS operations required to insert nodes is substantially lower than layered_map_sg. The poor performance of non-layered skip graphs also reflects a higher number of required CAS operations for insertion.

Another reason for why the LC-WH scenario appears meaningful is that it allows us to visualize the lower performance of lazy_layered_map_sg as compared to layered_map_sg, what we believe to be a direct consequence of our conservative commission policy to unlink invalid, marked nodes (p. 4). We think this happens as the commission policy (essentially, a lazy unlink policy) is making the shared structure contain more invalid or marked nodes present in the LC-WH scenario compared to the HC-WH or MC-WH scenarios. In any case, we do think that the commission policy overhead is a fair price for the highly increased performance in the MC and HC scenarios, yet still allowing us to outperform competitor maps in the LC-WH as well. A better NUMA locality, and decreased contention (verified in item #2, below) seems to be making up for the overhead in the LC-WH scenario. In the MC-WH scenario, we were very impressed with the performance of the nohotspot approach, noting that we just barely outperformed it. This further indicates that the commission policy might be subject to having a “sweet spot”, and thus our performance might be responsive to more elaborated commission policy designs, an interesting prospect for future work.

Appendix E More Experimental Results: RH tests

We present here results analogous to Figs. 4, 4, and 11, but showing performance on RH scenarios. Please refer to the discussion of p. 6.

Appendix F More Experimental Results: Locality Heatmaps

We present here results analogous to Figs.6 and 6, but showing read locality heatmaps. Please refer to the discussion of p. 4. The graphics presented here are not normalized by the total number of CAS operations. So, for example, the difference in scale between our lazy layered skip graph and a skip list, results from the former performing about 8x the number of operations of the latter.

We note that in Fig. 18, the vertical line at thread 1 represents accesses to the head array of the shared structure, which we arbitrarily attributed to that thread. We expect (and verify) that head accesses are more common with layered_map_ssg as compared to layered_map_sg, due to the smaller size of the shared structure.