Introduction to Concurrent Data Structures
Download as PPTX, PDF0 likes106 views
The document discusses concurrent data structures and their role in parallel and concurrent programming, highlighting methods like locks and non-blocking techniques such as wait-freedom and lock-freedom. It analyzes performance issues with traditional locking mechanisms and introduces advanced structures like combining trees and lock-free queues to optimize access to shared data. Additionally, it covers examples of implementation strategies, including a Java-based locking mechanism for a bounded queue.
![BlockingQueue
public class BlockingQueueExample {
public static void main(String[] args) throws Exception {
BlockingQueue queue = new ArrayBlockingQueue(1024);
Producer producer = new Producer(queue);
Consumer consumer = new Consumer(queue);
new Thread(producer).start();
new Thread(consumer).start();
Thread.sleep(4000);
}
} 42](https://image.slidesharecdn.com/13-concurrentdatastructures-240417105231-8e6b91c7/85/Introduction-to-Concurrent-Data-Structures-42-320.jpg)
Introduction to Concurrent Data Structures
- 1. Concurrent Data Structures CS5225 Parallel and Concurrent Programming Dilum Bandara [email protected] Some slides adapted from “The Art of Multiprocessor Programming” by Maurice Herlihy & Nir Shavit
- 2. Motivation Many/multi-core processors multiple threads working on shared data structures Shared-memory multiprocessors Threads communicate & synchronize through data structures Locks, semaphores, mutexex, monitors satisfy Safety & Liveness properties But they lack performance Make everything serial 2
- 3. Example – getAndIncrement() From prime number example with a shared counter 3 public class Counter { private long value; public long getAndIncrement() { return value++; } } temp = value; value = value + 1; return temp;
- 4. Example – Solution 4 public class Counter { private long value; public long getAndIncrement() { Lock() temp = value; value = temp + 1; Unlock() return temp; } } Synchronized block Mutual exclusion
- 5. Performance Problems With Locking Amdahl's law Code between Lock() & Unlock() is sequential Even a small sequential fraction reduces performance Memory contention Every processor need to access lock variable(s) Low performance on cache-coherent multiprocessors Blocking Thread holding lock, delay others e.g., blocking access to getAndIncrement() 5
- 6. Blocking Techniques Coarse grained blocking e.g., blocking an entire linked list Fine grained blocking e.g., blocking individual elements of a linked list What about our shared counter? Only 1 element to access A possible solution – combining tree 6
- 7. Combining Tree 7 Source: Shang Wang, Taolun Chai and Xiaoming Jia Concurrent Counting using Combining Tree
- 8. Combining Tree (Cont.) Threads climb tree from leaves towards root, while combining with other concurrent operations Every time operations of 2 threads are combined in an internal node, one thread wins & other looses Loser – waits at that node until a return value is delivered to it Winner – proceeds towards root carrying sum of all underlying operations Winner that reaches root adds its sum to counter Winner descends tree distributing a return value to each waiting loser 8
- 9. Combining Tree (Cont.) 9 Source: http://www.cs.berkeley.edu/~demmel/cs267/lecture14.html
- 10. Combining Tree (Cont.) Pros More parallelism Increments are parallel until root is updated p leaves take O(log p) to get a value Effective speed up O(p / log p ) Cons Parallelism reduces as threads go up the tree p is typically predefined Require O(p) states/memory Losers have to just spin (a.k.a local spinning) to prevent generation of any unnecessary memory traffic that may slowdown winner 10
- 11. Combining Tree (Cont.) Cons (cont.) Threads arriving after p need to wait Not efficient under low contention May lead to deadlocks Coordination among ascending winners, losers, & ascending late threads 11
- 12. Nonblocking Techniques Delay of a thread doesn’t cause delay of others By definition, these algorithms can’t use locks Nonblocking progress conditions 1. Wait-freedom 2. Lock-freedom 3. Obstruction-freedom 12
- 13. Nonblocking Techniques (Cont.) Wait-freedom A wait-free operation is guaranteed to complete after a finite no of its own steps Independent of others Lock-freedom A lock-free operation guarantees that after a finite no of its own steps, some operation completes Not necessarily itself Obstruction-freedom An obstruction-free operation is guaranteed to complete within a finite no of its own steps after it stops encountering interference from other operations 13
- 14. Nonblocking Techniques (Cont.) Wait-freedom is stronger than Lock-freedom Lock-freedom is stronger than Obstruction- freedom Stronger progress conditions are harder to implement Weaker guarantees are generally simpler e.g., can compensate for weaker progress conditions by employing backoff Shared counter can’t be implemented to be Wait- free & Lock-free without hardware support e.g., Compare-and-Swap (CaS) 14
- 15. Compare-and-Swap (CaS) There exists a wait-free implementation for any concurrent data structure in a system that supports CaS 15 bool CaS(L, E, N) { atomically { if (*L == E) { *L = N; return true; } else return false; } }
- 16. Shared Counter Based on CaS Implement getAndIncrement() using a CaS Solution is only lock-free Backoff is needed under heavy contention Sequential bottleneck & high contention for a single location 16 public class Counter { private long value; public long getAndIncrement() { temp = value; while(CaS(value, temp, temp + 1) == false) temp = value; return temp; } }
- 17. Linked Lists, Queues, & Stacks Pool of items Linked List Insert(), delete(), & member() Already looked at locking entire linked list, individual items, & read-write locks Queue First-in-first-out (FIFO) order enq() & deq() Stack Last-in-first-out (LIFO) order push() & pop() 17
- 18. Bounded vs. Unbounded Bounded Fixed capacity Good when resources are an issue e.g., bounded buffer, queue Unbounded Holds any number of objects 18
- 19. Blocking vs. Non-Blocking What to do when Removing from an empty pool? Adding to a full (bounded) pool? Blocking Caller waits until state changes Non-blocking Method throws exception e.g., retuning an error message or just dropping request 19
- 20. Queues & Stacks We’ll look at Bounded, blocking, lock-based queue Unbounded, non-blocking, lock-free queue Objective To enable modification of multiple memory locations atomically 20
- 21. Queue – Concurrency enq(x) y=deq() enq() & deq() work at different ends tail head 21
- 22. Concurrency enq(x) What if the queue is empty or full? y=deq() 22
- 24. Bounded Queue – Locking 2 Ends 24 head tail deqLock enqLock At most 1 deq() & enq() Need to also tell whether queue is full or empty
- 25. Bounded Queue 25 head tail deqLock enqLock Permission to enqueue 8 items Free slots 8
- 30. Dequeuer 30 head tail deqLock enqLock Free slots 7 Make first node new sentinel 8
- 31. Unsuccesful Dequeuer 31 head tail deqLock enqLock Free slots 8 Read sentinel’s next field uh-oh
- 32. Bounded Queue 32 public class BoundedQueue<T> { ReentrantLock enqLock, deqLock; Condition notEmptyCondition, notFullCondition; AtomicInteger freeSlots; Node head; Node tail; int capacity; enqLock = new ReentrantLock(); notFullCondition = enqLock.newCondition(); deqLock = new ReentrantLock(); notEmptyCondition = deqLock.newCondition(); }
- 33. Enq() & Deq() Methods Share no locks That’s good But do share an atomic counter Accessed on every method call That’s not so good as sequential bottleneck How to alleviate this bottleneck? 33
- 34. Solution – Split Counter enq() method Decrements only Cares only if value is zero deq() method Increments only Cares only if value is capacity Enqueuer decrements enqSideFreeSlots Dequeuer increments deqSideFreeSlots Then wakeup other party when only 0 or capacity is reached 34
- 35. Lock-Free Unbounded Queue Enqueue 35 head tail Enq( )
- 38. Enqueue These 2 steps aren’t atomic Tail field refers to either Actual last Node (good) Penultimate Node (not so good) What do you do if you find a trailing tail? Stop & help fix it If tail node has non-null next field CaS the queue’s tail field to tail.next 38
- 39. When CaSs Fail During logical enqueue Abandon & restart Still solution is lock-free During physical enqueue Ignore it as some other thread has executed in on behalf of current thread 39
- 40. Dequeuer 40 head tail Make first Node new sentinel CaS
- 41. Java Concurrency Utilities Package contains a set of classes that makes it easier to develop concurrent applications Lock ReadWriteLock BlockingQueue ArrayBlockingQueue DelayQueue LinkedBlockingQueue PriorityBlockingQueue SynchronousQueue BlockingDeque 41
- 42. BlockingQueue public class BlockingQueueExample { public static void main(String[] args) throws Exception { BlockingQueue queue = new ArrayBlockingQueue(1024); Producer producer = new Producer(queue); Consumer consumer = new Consumer(queue); new Thread(producer).start(); new Thread(consumer).start(); Thread.sleep(4000); } } 42
- 43. BlockingQueue (Cont.) public class Producer implements Runnable{ protected BlockingQueue queue = null; public Producer(BlockingQueue queue) { this.queue = queue; } public void run() { try { for (int i = 0; i < 1000; i++){ queue.put(i); Thread.sleep(1000); } } catch (InterruptedException e) { e.printStackTrace(); } } } 43