Lock-Free Data Structures

-by: Charvi Jagani (10bit055) -guided by: Vibha Patel

Last presentation:
Problems with locking CAS primitive Lock-free stack

ABA problem ABA solution

Lock free link-list

window class:
class Window{ public Node pred,curr; Window(Node myPred , Node myCurr){ pred=myPred; curr=myCurr; }

find() method returns a structure containing the nodes on either side of the key. It removes marked nodes when it encounters them. public Window find(Node head, int key) { Node pred=null, curr=null, succ=null; boolean[] marked={false}; boolean snip; retry: while (true) { pred=head; curr=pred.next.getReference(); while(true) { succ=curr.next.get(marked); while(true) { snip = pred.next.compareAndSet(curr,succ,false,false); if (!snip) continue retry; curr=succ; succ=curr.next.get(marked);

} if(curr.key >= key) return new Window(pred,curr); pred=curr; curr=succ; } } }

add() method calls find to locate predA and currA .It adds a new node only if predA is unmarked and refers to currA. public boolean add(T item){ int key=item.hashcode(); while(true){ Window window = find(head,key); Node pred=window.pred, curr=window.curr; if(curr.key == key){ return false; } else { Node node = new Node(item); node.next = new AtomicMarkableReference(curr,false); if (pred.next.compareAndSet(curr,node,false,false)){ return true; } } } }

remove() method calls find to locate predA and currA and atomically mark the nodes for removal.
public boolean remove(T item){ int key = item.hashcode(); boolean snip; while (true){ Window window = find(head, key); Node pred = window.pred, curr = window.curr; if(curr.key != key){ return false; } else{ Node succ = curr.next.getRefrence(); snip = curr.next.attemptMark(succ,true); if(!snip) continue; pred.next.compareAndSet(curr,succ,false,false); return true; }}}

Contains() method to check if a requested node is present or not. public boolean contains(T item) { boolean[] marked = false; int key = item.hashcode(); Node curr = head; while (curr.key < key){ curr=curr.next; Node succ = curr.next.get(marked); } return(curr.key == key && !marked[0]); } }

On the one hand, the LockFreeList algorithm guarantees progress in the face of arbitrary delays. However, there is a price for this strong progress guarantee: The need to support atomic modication of a reference and a Boolean mark has an added performance cost. As add() and remove() traverse the list, they must engage in concurrent cleanup of removed nodes, introducing the possibility of contention among threads, sometimes forcing threads to restart traversals, even if there was no change near the node each was trying to modify. Which approach is preferable depends on the application. In the end, the balance of factors such as the potential for arbitrary thread delays, the relative frequency of calls to the add() and remove() methods, the overhead of implementing an atomically markable reference, and so on determine the choice of whether to lock, and if so, at what granularity.

Throughput
The graphs show throughput (in rolls per second) for random number generation using various numbers of threads on a single-processor Pentium 4 box.
Reference: ibm.com/ java developer works

Thank You