Concurrent B-Skiplist

• Concurrent B-Skiplist is a block-based skiplist variant that groups multiple sorted keys per node, enhancing spatial locality and reducing pointer overhead.
• It employs a top-down, single-pass reader–writer locking protocol to support concurrent search, insertion, deletion, and range traversal with minimal contention.
• The design integrates probabilistic level assignment with fixed-size node management to achieve O(log_B n) access, outperforming traditional tree-based indices in key workloads.

Searching arXiv for the referenced Concurrent B-Skiplist and related skiplist papers. Concurrent B-Skiplist denotes a blocked skiplist that combines the layered linked-list topology of a skiplist with multi-key nodes or blocks, so that multiple sorted keys are stored contiguously in each node while concurrent search, insertion, deletion, and range traversal remain supported. In the surveyed literature, the term covers both a synthetic design space that merges block-aware skiplist layouts with concurrent skiplist techniques and a concrete in-memory realization that uses fixed-size nodes, contiguous arrays, and a top-down, single-pass reader–writer locking protocol (Xing et al., 2024, Luo et al., 29 Jul 2025). The topic sits at the intersection of skiplist theory, external-memory indexing, cache-sensitive layout design, and concurrent ordered-index engineering, and it inherits from earlier B-skip-list work the aim of obtaining $O(\log_B n)$-like access behavior while retaining simpler structural maintenance than tree-based alternatives (Golovin, 2010).

1. Origins, definition, and structural invariants

The antecedent of the concurrent form is the B-skip-list introduced as a “simpler uniquely represented alternative to B-trees,” where the structure is designed for external memory, has depth $O(\log_B(n))$, uses linear space with high probability, and supports efficient one-dimensional range queries (Golovin, 2010). In later tutorial and survey treatments, a B-skiplist is described more generally as a block-based, blocked, or cache-conscious skiplist variant that groups multiple consecutive keys into fat nodes or blocks in order to exploit spatial locality and reduce pointer overhead (Vadrevu et al., 2023, Xing et al., 2024).

In the blocked formulation, level 0 remains a sorted list of all elements, while higher levels act as express lanes. The 2025 in-memory formulation states the inclusion invariant explicitly: if a key appears at level $\ell$, it also appears at all levels $0,\dots,\ell-1$ (Luo et al., 29 Jul 2025). Node organization is correspondingly block-centric rather than element-centric. Each node has a header key, defined there as the smallest key in the node, and every header of a level-$\ell$ node must be promoted to level $\ell+1$ (Luo et al., 29 Jul 2025). Keys and values are laid out in contiguous arrays within the node, and internal nodes at level $\ell>0$ additionally store an array of down pointers aligned with the keys (Luo et al., 29 Jul 2025). The survey’s synthetic design expresses the same idea at a coarser level: blocked nodes of size $B$ group multiple keys per node, and each level is a list of block pointers whose leaders or pivots summarize the covered ranges (Xing et al., 2024).

This blocked organization changes the unit of structure, synchronization, and locality. Traditional skiplists store one key per node, whereas a B-skiplist stores multiple sorted keys per node or per logical block (Luo et al., 29 Jul 2025). A plausible implication is that the concurrency problem shifts from maintaining many fine-grained next pointers to coordinating fewer, denser nodes whose internal arrays, down-pointer arrays, and split boundaries must remain consistent under concurrent access.

2. Probabilistic model, occupancy, and memory hierarchy

Concurrent B-skiplists preserve skiplist probabilistic level assignment. Standard skiplist analysis uses a promotion probability $p$, with geometric level distribution and expected height $E[H] \approx O(\log_{1/p} n)$ (Xing et al., 2024). The 2025 concurrent design keeps this framework but adapts it to blocking: height assignment uses independent coin flips with promotion probability $O(\log_B(n))$0, and “in B-skiplists $O(\log_B(n))$1 to achieve blocking” (Luo et al., 29 Jul 2025). With that choice, the expected number of keys stored per logical node is $O(\log_B(n))$2, although the maximum number of keys per logical node is $O(\log_B(n))$3 with high probability (Luo et al., 29 Jul 2025).

The same paper defines high probability as

$O(\log_B(n))$4

for some constant $O(\log_B(n))$5, gives the height distribution as

$O(\log_B(n))$6

and states that the maximum height is $O(\log_B(n))$7 both in expectation and with high probability (Luo et al., 29 Jul 2025). Because logical nodes can become too large under randomization, the implementation enforces fixed-size physical nodes. When a logical node exceeds capacity $O(\log_B(n))$8, it is represented by multiple fixed-size nodes chained by next pointers at the same level; this overflow split bounds worst-case element moves in a single node to $O(\log_B(n))$9 (Luo et al., 29 Jul 2025).

The memory-hierarchy motivation is explicit across the literature. The 2025 design targets cache locality by choosing node size $\ell$0 proportional to cache-line size, uses contiguous storage for keys and values, and supports binary search or small linear scans within nodes (Luo et al., 29 Jul 2025). The survey’s synthetic external-memory perspective similarly treats blocked nodes as pages of size $\ell$1, with top-level navigation through leaders or pivots and base-level range traversal over blocks (Xing et al., 2024). Earlier B-skip-list work fixes parameters so that expected partition size aligns with block size, again tying probabilistic structure to the block-transfer model (Golovin, 2010).

This synthesis suggests that “Concurrent B-Skiplist” is not a single fixed layout but a family of skiplist-derived structures parameterized by block size, promotion probability, and hardware target. In DRAM-oriented designs, the emphasis is LLC behavior and bounded in-node work; in external-memory and persistent-memory formulations, the same blocked organization is used to reduce random I/O or persistence traffic (Xing et al., 2024, Luo et al., 29 Jul 2025).

3. Search, insertion, deletion, and range traversal

Search in a concurrent B-skiplist remains top-down. In the 2025 in-memory design, find starts at the topmost left sentinel, traverses left-to-right via next pointers until the next header exceeds the target key, performs in-node search to locate the predecessor slot and corresponding down pointer, follows the down pointer, and repeats until level 0 (Luo et al., 29 Jul 2025). At level 0, presence is checked in the contiguous array. The survey’s synthetic block-aware search is analogous: navigate leaders at top levels, descend through block pointers, and use binary search or SIMD in the base block (Xing et al., 2024).

The central algorithmic contribution in the 2025 paper is a top-down, single-pass insertion algorithm. The height $\ell$2 is determined upfront by random coin flips; nodes for levels $\ell$3 are preallocated and linked vertically via down pointers; traversal proceeds read-only above level $\ell$4; at level $\ell$5 the key is inserted into the predecessor node; overflow is handled by allocating a new fixed-size node, linking it between the predecessor and successor, and moving half or boundedly many of the largest keys before inserting; then the algorithm descends and splices the preallocated promoted nodes at lower levels (Luo et al., 29 Jul 2025). The inclusion invariant holds after the insertion finishes (Luo et al., 29 Jul 2025).

Deletes are described as symmetric in the same source: locate the key at level 0, remove it, then remove corresponding promoted occurrences and possibly merge or split nodes as needed, with fixed-size nodes again bounding per-node work (Luo et al., 29 Jul 2025). The survey’s synthetic design broadens deletion options: entries may be marked as ghost entries and cleaned lazily during rearrangement or flush, or logical deletion may use marker nodes or null values in a CAS-based style (Xing et al., 2024).

Range queries exploit the blocked base layer. In the 2025 design, a range operation first performs a find for the start key and then iterates left-to-right at level 0, acquiring subsequent nodes’ keys until enough elements are returned or the right sentinel is reached (Luo et al., 29 Jul 2025). The survey describes the corresponding external-memory behavior as starting from the leftmost base block covering the start key and scanning blocks sequentially, with range-search I/O complexity $\ell$6 in the write-optimized formulation (Xing et al., 2024). A plausible implication is that blocked skiplists preserve the classic skiplist advantage on ranges while making the scan phase materially more locality-friendly because bottom-level keys are array-packed rather than node-separated.

4. Concurrency control mechanisms

The most explicit concurrent B-skiplist protocol in the provided literature is the top-down reader–writer scheme of the 2025 paper. Its stated goals are a single root-to-leaf pass, at most a constant number of locks held at once, and at most two levels locked concurrently (Luo et al., 29 Jul 2025). Reader–writer locks are maintained per node. Finds and ranges acquire read locks only and proceed hand-over-hand left-to-right within levels, then top-to-bottom between levels, holding at most two locks at a time (Luo et al., 29 Jul 2025). Inserts compute height and preallocate their node stack, traverse levels above $\ell$7 with read locks only, switch to write locks at level $\ell$8, and then continue downward in write mode to splice promoted nodes. The protocol may momentarily hold at most three write locks during promotion splits and at most two during overflow splits (Luo et al., 29 Jul 2025). Deadlock freedom follows from a total lock acquisition order: left-to-right within a level, then top-to-bottom across levels (Luo et al., 29 Jul 2025).

The broader survey presents this scheme as one point in a larger design space. For lock-based concurrency, it draws on optimistic skiplist techniques in which searches are lock-free or read-only until the modification point, then predecessor and current nodes are locked and adjacency and non-marked status are validated before splicing (Xing et al., 2024). For blocked nodes specifically, it notes group mutual exclusion within a block as a way to allow threads operating on different keys in the same node to proceed concurrently (Xing et al., 2024). For lock-free adaptations, it suggests Harris-style logical deletion, CAS splicing of block-level list pointers, and Fomitchev–Ruppert-style three-step deletion with back pointers for helping after failed CAS attempts (Xing et al., 2024).

The same survey emphasizes decoupling and background maintenance. A contention-friendly design decouples base-level data modifications from index-level updates and uses an adaptive background thread to raise or lower towers and clean logically deleted entries (Xing et al., 2024). Rotating layouts lower towers by incrementing a global ZERO atomically so that logical levels are reinterpreted without physically touching all pointers (Xing et al., 2024). In distributed or RDMA settings, concurrency may instead be structured through partitioned ownership by top-level leaders, serialized writes per partition, and verification flags for remote-read atomicity (Xing et al., 2024).

These mechanisms reveal a common pattern: concurrency in a B-skiplist can be localized because the structure does not require global rebalancing. That does not eliminate synchronization complexity, but it changes its shape. The critical path typically consists of block-local insertion or deletion, occasional local split or merge, and limited upper-level splice operations, rather than tree-wide occupancy repair.

5. Architectural variants: external memory, persistent memory, NUMA, and batched parallelism

The survey identifies several block-aware skiplist families that can be interpreted as concurrent B-skiplist variants or ingredients (Xing et al., 2024). In external memory, Bender et al.’s write-optimized skiplist is organized around block-based nodes containing pivots and buffers of pending items; inserts are buffered and flushed on overflow, and range searches cost $\ell$9 I/Os with high probability (Xing et al., 2024). FlashSkipList combines an append-only top list with a chunked read-optimized component, using back-pointers to avoid erases and ghost entries for logical deletion (Xing et al., 2024). Persistent-memory designs such as NV-skiplist, AS/ASCS, and PhaST group multiple entries per node, reduce persistence traffic by reconstructing internal levels after crash, or validate readers against late max-key updates during splits (Xing et al., 2024).

Cache-sensitive and SIMD-oriented work pushes the same blocked principle toward in-memory parallelism. Cache-sensitive skiplists linearize index layers into arrays and compute child positions arithmetically rather than through pointers (Xing et al., 2024). PI stores upper-level entries contiguously, uses SIMD comparisons and routing tables, batches queries, partitions them across threads, and redistributes conflicts so that each modified data node is handled by exactly one thread; the paper reports that PI can be up to three times as fast as Masstree (Xie et al., 2016). This is not an online per-node locking design, but it demonstrates a distinct concurrency model for blocked skiplist-like indexing: batched, latch-free range ownership rather than immediate structural locking (Xie et al., 2016).

A further direction is multiversioning. Jiffy is a multiversioned lock-free skip list whose lowest-level nodes hold immutable “revisions,” that is, grouped key-value entries stored in contiguous arrays; it supports lock-free snapshots, batch updates, and split/merge of fat nodes, and the paper describes this organization as a natural mapping to a concurrent B-skiplist (Kobus et al., 2021). This suggests that blocking and multiversion concurrency are not separate lines of work: immutable block revisions can serve simultaneously as locality units, synchronization granules, and snapshot/version boundaries.

Across these variants, the term “Concurrent B-Skiplist” therefore names a structural idea more than a single implementation recipe. The unifying features are blocked nodes, skiplist-level probabilistic indexing, and concurrency control adapted to block granularity; the particular mechanisms differ across DRAM, flash, PM, NUMA, and RDMA environments (Xing et al., 2024).

6. Performance characteristics, trade-offs, and relation to tree-based indices

The 2025 in-memory concurrent B-skiplist paper provides the clearest quantitative evidence. On 128 threads, it reports between 2x–9x higher throughput than state-of-the-art concurrent skiplists including Folly and Java ConcurrentSkipListMap, competitive throughput of 0.9x–1.7x on point workloads relative to cache-optimized tree-based indices, and between 3.5x–103x lower 99% latency than other concurrent skiplists on the studied point workloads with inserts (Luo et al., 29 Jul 2025). It also reports 3.2–5.6× fewer LLC load misses than Folly on tested workloads (Luo et al., 29 Jul 2025). On workload A with a uniform distribution, the reported 99% latency is approximately $0,\dots,\ell-1$0 for the B-skiplist, versus approximately $0,\dots,\ell-1$1 for the B+-tree and approximately $0,\dots,\ell-1$2 for Masstree (Luo et al., 29 Jul 2025). In the load phase, the B+-tree took the root write lock approximately 26K times versus approximately 7 times for the B-skiplist; in workload A the counts were approximately 8.3K versus approximately 3 (Luo et al., 29 Jul 2025).

These data support a specific interpretation of the B-skiplist/tree comparison. B-trees maintain higher and more deterministic node density and therefore can retain an advantage on long ranges; the 2025 paper states that its B+-tree achieved approximately 1.4× higher throughput on the studied range workload because of higher deterministic leaf-node density (Luo et al., 29 Jul 2025). At the same time, the B-skiplist avoids second root-to-leaf passes and root-lock amplification associated with optimistic tree updates, which the paper uses to explain lower contention and better tail latency on insert-heavy point workloads (Luo et al., 29 Jul 2025).

Theoretical complexity statements track this empirical picture. In the 2025 in-memory model, expected finds and inserts cost $0,\dots,\ell-1$3 cache-line transfers when $0,\dots,\ell-1$4, expected ranges of size $0,\dots,\ell-1$5 cost $0,\dots,\ell-1$6, and worst-case behavior with high probability remains $0,\dots,\ell-1$7 transfers because long runs can still occur (Luo et al., 29 Jul 2025). Earlier B-skip-list analysis in the external-memory model gives expected $0,\dots,\ell-1$8 I/Os for lookup, insert, and delete, plus $0,\dots,\ell-1$9 for range queries (Golovin, 2010). The survey’s synthesis presents analogous expectations for blocked concurrent designs, typically framed as $\ell$0-like search and $\ell$1 range costs in write-optimized blocked layouts (Xing et al., 2024).

Parameter tuning is correspondingly central. The literature repeatedly ties performance to the joint choice of block size $\ell$2 and promotion probability $\ell$3. The 2025 implementation used fixed-size nodes of 2048 bytes, 128 key–value pairs of 16 bytes each, $\ell$4, and thus $\ell$5 in its sensitivity study (Luo et al., 29 Jul 2025). The survey gives the more general guidance that $\ell$6 near $\ell$7 is stable for classic skiplists, $\ell$8 reduces memory, and blocked external-memory designs should calibrate $\ell$9 and the effective sampling rate to the block size (Xing et al., 2024). This suggests that a concurrent B-skiplist is best understood not as a universally dominant replacement for trees, but as a tunable ordered index whose main strengths are locality-preserving point access, simple local structural maintenance, and concurrency schemes that avoid global rebalance and broad critical sections.

7. Conceptual significance and common misunderstandings

One recurring misunderstanding is to treat a concurrent B-skiplist as merely an “unrolled skiplist.” The literature is broader. Some variants simply group multiple keys per node to reduce pointer chasing; others use fixed-size nodes with aligned down-pointer arrays; others use buffers and pivots for external memory; still others use immutable revisions, batch processing, or deterministic partitioning for unique representation (Xing et al., 2024, Luo et al., 29 Jul 2025, Kobus et al., 2021, Golovin, 2010). The common denominator is blocked skiplist organization under concurrency, not a single node layout.

A second misunderstanding is that blocking removes probabilistic irregularity. It does not. The 2025 paper states that logical node occupancy can still reach $\ell+1$0 with high probability, which is precisely why fixed-size physical nodes and overflow chaining are introduced (Luo et al., 29 Jul 2025). Blocking improves expected locality and reduces height, but it does not by itself eliminate long runs or the need for split policies.

A third misunderstanding is that skiplists and trees differ only asymptotically. The literature instead emphasizes different maintenance disciplines. B-trees enforce deterministic occupancy and balanced descent, whereas B-skiplists retain randomized heights and tolerate variable node density, using local split and merge without rotations or global rebalance (Vadrevu et al., 2023, Luo et al., 29 Jul 2025). This suggests that the principal distinction is operational rather than merely asymptotic: a concurrent B-skiplist trades some density regularity for simpler update paths and, in the measured in-memory design, substantially lower tail latency under insert-heavy contention (Luo et al., 29 Jul 2025).

Taken together, the literature presents Concurrent B-Skiplist as a convergent index design in which blocking, probabilistic layering, and concurrent locality-aware maintenance reinforce one another. Its exact realization varies—from uniquely represented external-memory structures to cache-optimized memtable replacements—but the central idea remains stable: make the skiplist’s ordered express-lane topology operate at block granularity, and make concurrency act on those blocks rather than on individual keys.