SkipLists and Balanced Search The Art Of MultiProcessor Programming Maurice Herlihy & Nir Shavit Chapter 14 Avi Kozokin

Intro Introduction: SkipList – what, why & how. a reminder LazySkipList – a lock based concurrent SkipList LockFreeSkipList – lock free concurrent SkipList

SkipList – what Collection of unique keys Comprised of levels – each level is a sorted linked list. Level - O contains all nodes, and each level is a subset of the lower levels. Mimics a balanced search tree. Height is logarithmic. Each link at level i skips roughly nodes. Probabilistic data structure. We assume that contains() is called more than the rest of the methods

SkipList – what Collection of unique keys Comprised of levels – each level is a sorted linked list. Level - O contains all nodes, and each level is a subset of the lower levels. Mimics a balanced search tree. Height is logarithmic. Each link at level i skips roughly nodes. Probabilistic data structure. We assume that contains() is called more than the rest of the methods

SkipList – why Balanced search trees, (such as AVL trees) provide logarithmic performance of search, add & remove methods. The problem is the maintenance – need to rebalance the data structure after each change (rolling in AVL). SkipList provides a solution: uses randomization to achieve logarithmic performance in average. Randomization happens on insertion of an element We choose: 0<p<1 to be the probability for a node to appear in level i given that it appears in level i-1. all nodes appear in level 0. this means the probability of a node to appear in level i is. Note that if it appears in level i – it appears in all lower levels.

SkipList – how Every Node has a topLevel – index of the highest list in which it is present. Every Node has an array of references to nodes – next node on each level. SkipList has head and tail nodes, with keys smaller and bigger than any possible key, respectively. head and tail appear on every level, and initially head’s next points to tail. SkipList has a maximal level. (can be dynamically maintained). Finding nodes by traversing every list starting from the top, and descending whenever we find the largest key in the level which is not bigger than the searched node’s key.

Find() Traverses the list Fills 2 arrays: preds[] and sucss[] pred[i] is a reference to the node in level i that has the biggest key that is smaller than the searched key. succ[i] is pred[i]’s successor Returns the node’s top level if found If not found – returns -1

Find() Traverses the list Fills 2 arrays: preds[] and sucss[] pred[i] is a reference to the node in level i that has the biggest key that is smaller than the searched key. succ[i] is pred[i]’s successor

Add() Uses find() to fill the preds[] and succs[]. Generates a random topLevel. If find() returned a top level – returns false (the key is already in the list) If not found - inserts the node between preds[i] and succs[i] in every level from 0 to topLevel

Add() - example Uses find() to fill the preds[] and succs[]. Generates a random topLevel. If find() returned a top level – returns false (the key is already in the list) If not found - inserts the node between preds[i] and succs[i] in every level from 0 to topLevel

LazySkipList

A lock based concurrent SkipList Each level of the SkipList is a LazyList Add() & remove() use optimistic fine grained locking Contains() is wait-free

LazyList – a reminder Every node has a marker – if set, that means that the node was logically removed from the set. Add() & remove() methods traverse the list without locking, searching for the node’s predecessor and successor (the node itself incase of remove) After finding the predecessor and successor, locking them Validating – both pred and curr aren’t marked, and preds next is in fact curr. If validation succeeds – continue with method. If validation failed – go again.

LazySkipList Maintains the SkipList property – each level is a subset of it’s lower levels Using locks near the modified node to achieve this property. Every node has an additional indicator if the node is fullyLinked – meaning that the node is linked in every level it should be linked (up to it’s top level) We delay access to a node until it is fullyLinked

LazySkipList

Add() Calls find() to fill preds[] and succs[] (find is the same as sequential find) Locks preds[] Checks if the node is already in the set (spins if not fully linked) and returns false if so. Validates preds[]. If validation fails – tries again. Makes preds[] point to our node and the node to point to the sucss[] Sets fullyLinked

example

Find() Keeps pred’s key strictly smaller than searched key

Find()

If the node is found And unmarked we wait until it’s Fully linked and then finish

Remove() Uses find as well Locks the node, and checks if it is unmarked, and if the node is fully linked and at it’s top level (if not – not yet fully linked or marked and is being removed) Locks preds[] and validates. If fails – tries again. Removes from top to bottom to maintain the SkipList property

Contains() Wait free Uses find() Validates result

Lock-Free Concurrent SkipList

Also based on a concurrent list implementation – LockFreeList Each level of the SkipList is a LockFreeList No locks in this implementation Only CAS operations We will achieve a wait free contains() here as well

LockFreeList Every node’s next reference is an AtomicMarkableReference CompareAndSet(expected_val,new_val,expected_mark,new_mark) Get(mark_holder[] )– returns the reference and puts mark in mark_holder attemptMark(val,mark) – if references value == val then mark. Essentially, using CASes to mark and remove: one CAS to check if the node still points to it’s successor and a second CAS to physically remove it. Find() cleans up marked nodes

LockFreeSkipList - Overview We cannot maintain the SkipList property this time. The set is defined by the bottom level – if a node is there and unmarked it’s in the set (no need for fullyLinked flag) Adding by using CAS to insert a node at each level. Removing by marking the node’s next reference. Find() fills preds[] cleans up marked nodes while traversing.

Find(x) & contains(x) Traverses the lists, from top level to bottom. Never traverses marked nodes. filling preds[] with references to nodes with largest key that’s strictly smaller than x, while using CAS to eliminate marked nodes. Contains() does the same except it doesn’t eliminate marked nodes but simply skips over them.

Add() Uses find() to check presence and to fill preds[] and sucss[] Directs new node’s nexts to sucssessors Tried to add to bottom level using CAS. If it fails – calls find again. Adds to higher levels

Add()

Remove() Also uses find(), searching for an unmarked node in the bottom level marks the node, starting from it’s top level If all marks were successful up to the bottom level, marks the bottom level Physically removed by remove itself or find() of other threads

Summary We recalled what is a SkipList Seems weird, but provides an elegant alternative to a search tree Seen 2 different concurrent SkipLists One uses locks The other doesn’t Both achieve logarithmic performance and a wait free contains() method

Thanks!