Post on 18-Jan-2018
description
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 restof the methods
2i
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 restof the methods
2i
https://en.wikipedia.org/wiki/Skip_list
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.
ip
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 biggestkey 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
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
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()
Find()
If the node is foundAnd 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
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()
Add()
Add()
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!