Gal Milman Based on Chapter 10 (Concurrent Queues and the ABA Problem) in The Art of Multiprocessor Programming by Herlihy and Shavit Seminar 2 (236802) in Advanced Topics in Concurrent Programming Winter 15/16 Instructor: Erez Petrank Concurrent Queues

background: Pool Provides Put, Get methods. The same item can appear more than once. Often acts as producer-consumer buffer.

Provides Put, Get methods. The same item can appear more than once. Often acts as producer-consumer buffer. Pool Properties: Capacity: bounded / unbounded Methods: total / partial / synchronous Fairness: queue (FIFO) / stack (LIFO) /…

Queue DequeueEnqueue Tail Head (Get)(Put) next

Q u e u e We will review: Blocking Queue Lock-Free Queue o ABA Problem Synchronous Dual Queue

Blocking Queue Initialization: tail = head = Node(value=null) capacity = input_capacity size = AtomicInteger(0) enqLock, deqLock notFullCondition, notEmptyCondition tail head next tail head next value next value Dummy node

public void addNode(T x) { Node newNode = new Node(x); tail.next = newNode; tail = newNode; } tail head tail x newNode Blocking Queue - enq head 1 2

public T removeNodeAndGetValue() { result = head.next.value; head = head.next; return result; } Blocking Queue - deq head tail x head tail x

public void enq(T x) { addNode(x); size.getAndIncrement() } Blocking Queue - enq enqLock.lock(); while (size.get() == capacity) notFullCondition.await(); enqLock.unlock(); boolean mustWakeDequeuers = false; if ( == 0) mustWakeDequeuers = true; if (mustWakeDequeuers) { deqLock.lock(); notEmptyCondition.signalAll(); deqLock.unlock(); }

public void enq(T x) { addNode(x); size.getAndIncrement() } Blocking Queue - enq enqLock.lock(); while (size.get() == capacity) notFullCondition.await(); enqLock.unlock(); boolean mustWakeDequeuers = false; if ( == 0) mustWakeDequeuers = true; if (mustWakeDequeuers) { deqLock.lock(); notEmptyCondition.signalAll(); deqLock.unlock(); } deq is symmetrical. Why should we lock before signaling? deqenq deqlock.lock() while (queue is empty) notEmptyCondition.await() addNode() notEmptyCondition.signalAll() Why should we lock before signaling? To avoid the lost wakeup problem.

Unbounded Blocking Queue Unbounded => size and capacity are unnecessary Total => conditions are unnecessary Initialization: tail = head = Node(value=null) enqLock, deqLock tail head next

Unbounded Blocking Queue - enq, deq public void enq(T x) { addNode(x); } enqLock.lock(); enqLock.unlock(); public T deq() throws EmptyException { if (head.next == null) throw new EmptyException(); T result = removeNodeAndGetValue(x); return result; } deqLock.lock(); deqLock.unlock();

Abstract vs. Concrete The queue’s actual (abstract) head and tail are not necessarily the items referenced by head and tail. The actual head is the successor of the node referenced by head. The actual tail is the last item reachable from the head. Unbounded Blocking Queue

Q u e u e We will review: Blocking Queue Lock-Free Queue o ABA Problem Synchronous Dual Queue progress performance

Blocking Algorithms Cons Performance on a multi-core processor Using several locks is exposed to error conditions like deadlock Contention instead of progress: A blocked thread does not make any progress. If the thread that holds the lock gets stuck - the threads that try to acquire the lock get stuck. A data structure protected by a lock cannot safely be accessed in an interrupt handler, as the preempted thread may be the one holding the lock. Sources:

Non-Blocking Algorithms Non-blocking – failure or suspension of any thread cannot cause failure or suspension of another thread. Lock-free – There is guaranteed system-wide progress. / Some thread finishes in a finite number of steps. Wait-free – There is guaranteed per-thread progress. / Every thread finishes in a finite number of steps. Source:

Lock-Free Algorithms In the absence of locks: Use atomic read-modify-write hardware primitives, like CAS But what about an action that is composed of several atomic primitive calls? o It should mark the data structure, so other threads may finish the action. "lock" "unlock"

Initialization: Unbounded ⇒ size and capacity are unnecessary Lock-free ⇒ locks and conditions are unnecessary tail = head = Node(value=null) * head, tail and Node.next are AtomicReference tail head next Lock-Free Queue

while (true) { if (next == null) { if ( ) { } } else { tail.compareAndSet(last, next); } } Lock-Free Queue - enq public void enq(T x) { Node node = new Node(x); Node last = tail.get(); Node next = last.next.get(); last.next.compareAndSet(next, node) tail.compareAndSet(last, node); return; }

Lock-Free Queue - deq while (true) { if ( ) tail.compareAndSet(last, next); } public T deq() throws EmptyException { Node first = head.get(); Node last = tail.get(); Node next = first.next.get(); if (first != last) { T value = next.value; head.compareAndSet(first, next) return value; } else { if (next == null) throw new EmptyException(); } }

ABA Problem Consider our lock-free queue But stop relying on Java’s garbage collector Each thread will maintain a private free list Now we encounter the ABA problem

head tail x a b head tail y b head tail b a free list (2) a tail a head b free list (2) tail a head b enq(y) deq 1 2 free list (2)

ABA Solution: A Stamp AtomicStampedReference encapsulates: a reference to Node an integer stamp AtomicReference AtomicStampedReference stamp is incremented in each compareAndSet. replaced by

Q u e u e We will review: Blocking Queue Lock-Free Queue o ABA Problem Synchronous Dual Queue

reservationfulfilment

head tail y x head tail head NotEmpty Condition -deq1 -deq2 -… Blocking Queue States head tail y x Synchronous Dual Queue States head tail null tail head enq reservations deq reservations In the dual queue - enq and deq are symmetrical. Both check queue’s state to figure out if they should be a reserver or a fulfiller. fair vs.

Synchronous Dual Queue Reserver adds an item to the queue, Other threads might finish the addition then spins on the item Fulfiller changes the item rendezvous To end the rendezvous - the item is removed from the queue Other threads might execute the removal lock- free lock- free