Building Efficient Concurrent Graph Object through Composition of List-based Set
|
|
|
- Diana Palmer
- 5 years ago
- Views:
Transcription
1 Building Efficient Concurrent Graph Object through Composition of List-based Set Sathya Peri Muktikanta Sa Nandini Singhal Department of Computer Science & Engineering Indian Institute of Technology Hyderabad AADDA Workshop in Conjunction with ICDCN 2018 January 4, 2018 Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
2 Outline of the Presentation 1 Motivation 2 Problem Definition 3 Our Methodology 4 Working of the methods 5 Correctness 6 Empirical Results 7 Conclusion & Future Work Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
3 Outline of the Presentation 1 Motivation 2 Problem Definition 3 Our Methodology 4 Working of the methods 5 Correctness 6 Empirical Results 7 Conclusion & Future Work
4 Graphs are Everywhere... Common real world objects can be modeled as graphs, which build the pairwise relations between objects. Graphs are used in the fields: genomics, networks, coding theory, scheduling, computational devices, networks, organization of similar and dissimilar objects, etc. Day by day the size of the above graphs are increasing exponentially. Generally, these graphs are very large and dynamic in nature. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
5 Graphs are Everywhere... Common real world objects can be modeled as graphs, which build the pairwise relations between objects. Graphs are used in the fields: genomics, networks, coding theory, scheduling, computational devices, networks, organization of similar and dissimilar objects, etc. Day by day the size of the above graphs are increasing exponentially. Generally, these graphs are very large and dynamic in nature. Fully Dynamic Graphs allow both insertions and deletions. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
6 Need for a Concurrent Graph Data Structure Processes acting on a dynamic graph needs to update it frequently and run computations. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
7 Need for a Concurrent Graph Data Structure Processes acting on a dynamic graph needs to update it frequently and run computations. 1 If global lock is used, then global bottleneck 2 Partition the graph into disjoint sets. Any update to the graph leads to re-partitioning expensive! Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
8 Need for a Concurrent Graph Data Structure Processes acting on a dynamic graph needs to update it frequently and run computations. 1 If global lock is used, then global bottleneck 2 Partition the graph into disjoint sets. Any update to the graph leads to re-partitioning expensive! Need for Independent access to disjoint parts of graph. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
9 Outline of the Presentation 1 Motivation 2 Problem Definition 3 Our Methodology 4 Working of the methods 5 Correctness 6 Empirical Results 7 Conclusion & Future Work
10 Problem Statement Given a initial graph G = (V, E), where V is the set of vertices and E is the set of edges. Threads can perform six basic operations: Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
11 Problem Statement Given a initial graph G = (V, E), where V is the set of vertices and E is the set of edges. Threads can perform six basic operations: 1 add Vertex(v) 2 add Edge(u, v) Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
12 Problem Statement Given a initial graph G = (V, E), where V is the set of vertices and E is the set of edges. Threads can perform six basic operations: 1 add Vertex(v) 2 add Edge(u, v) 3 delete Vertex(v) 4 delete Edge(u, v) Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
13 Problem Statement Given a initial graph G = (V, E), where V is the set of vertices and E is the set of edges. Threads can perform six basic operations: 1 add Vertex(v) 2 add Edge(u, v) 3 delete Vertex(v) 4 delete Edge(u, v) 5 ContainsEdge(u, v) 6 ContainsVertex(u) Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
14 Problem Statement Given a initial graph G = (V, E), where V is the set of vertices and E is the set of edges. Threads can perform six basic operations: 1 add Vertex(v) 2 add Edge(u, v) 3 delete Vertex(v) 4 delete Edge(u, v) 5 ContainsEdge(u, v) 6 ContainsVertex(u) Note: This is a directed unweighted simple graph. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
15 Difficulties with Fully Dynamic Graphs Figure : Thread T 1 & T 3 adding the vertex 10 and the edge(9, 8) respectively, on the other hand the thread T 2 wants to delete the vertex 3. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
16 Dynamic Graphs Dynamic graph algorithms perform better than their static counterparts because of increased data parallelism. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
17 Dynamic Graphs Dynamic graph algorithms perform better than their static counterparts because of increased data parallelism. However proving the correctness is more challenging as they allow concurrent access at a finer granularity and access common data items. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
18 Outline of the Presentation 1 Motivation 2 Problem Definition 3 Our Methodology 4 Working of the methods 5 Correctness 6 Empirical Results 7 Conclusion & Future Work
19 Contribution Representation of concurrent directed graph data structure as an adjacency list which has been implemented as a concurrent set based on linked list. [Steve Heller, et al.] Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
20 Methods Exported 1 AddVertex(u) adds a vertex u to G, returning true iff vertex u was not already in G else false. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
21 Methods Exported 1 AddVertex(u) adds a vertex u to G, returning true iff vertex u was not already in G else false. 2 RemoveVertex(u) deletes vertex u from G, returning true iff u was present else returns false. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
22 Methods Exported 1 AddVertex(u) adds a vertex u to G, returning true iff vertex u was not already in G else false. 2 RemoveVertex(u) deletes vertex u from G, returning true iff u was present else returns false. 3 AddEdge(u, v) adds a directed edge (u, v) to the concurrent G, returning true iff (u, v) was not already present in G else returns false. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
23 Methods Exported 1 AddVertex(u) adds a vertex u to G, returning true iff vertex u was not already in G else false. 2 RemoveVertex(u) deletes vertex u from G, returning true iff u was present else returns false. 3 AddEdge(u, v) adds a directed edge (u, v) to the concurrent G, returning true iff (u, v) was not already present in G else returns false. 4 RemoveEdge(u,v) deletes the directed edge (u, v) from G, returning true iff (u, v) was already there else returns false. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
24 Methods Exported 1 AddVertex(u) adds a vertex u to G, returning true iff vertex u was not already in G else false. 2 RemoveVertex(u) deletes vertex u from G, returning true iff u was present else returns false. 3 AddEdge(u, v) adds a directed edge (u, v) to the concurrent G, returning true iff (u, v) was not already present in G else returns false. 4 RemoveEdge(u,v) deletes the directed edge (u, v) from G, returning true iff (u, v) was already there else returns false. 5 ContainsEdge(u,v) returns true iff G contains the edge (u, v) else returns false. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
25 Methods Exported 1 AddVertex(u) adds a vertex u to G, returning true iff vertex u was not already in G else false. 2 RemoveVertex(u) deletes vertex u from G, returning true iff u was present else returns false. 3 AddEdge(u, v) adds a directed edge (u, v) to the concurrent G, returning true iff (u, v) was not already present in G else returns false. 4 RemoveEdge(u,v) deletes the directed edge (u, v) from G, returning true iff (u, v) was already there else returns false. 5 ContainsEdge(u,v) returns true iff G contains the edge (u, v) else returns false. 6 ContainsVertex(u) returns true iff G contains the vertex u else returns false. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
26 Construction of Concurrent List based Directed Graph Concurrent Graph Data Figure Structure : Graph and itsiitrepresentation Hyderabad Jan 4, /48
27 Concurrent List-based Set Set implemented using linked-list, a collection of items that contains no duplicate elements and exported methods are: 1 add(x): adds x to the set, returning true if, and only if x was not already present earlier. 2 remove(x): removes x from the set, returning true if, and only if x was there. 3 contains(x): returns true if, and only if the set contains x. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
28 Variants 1 Sequential: Only one thread and No Lock. 2 Coarse-grained synchronization: Uses Single Spin Lock. 3 Fine-grained synchronization: Split the object into independently synchronized components. 4 Optimistic synchronization: Search without acquiring any locks. 5 Lazy synchronization: Postpone the hard work, a node has a bool marked field: logically removal (setting a marked bit) and physical removal (unlinking). 6 Non-blocking synchronization: No locks and use the built-in atomic operations compareandset() for synchronization. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
29 Correctness and Progress Conditions Designing of any method or data-structure in the concurrent world, needs to satisfy these two properties: [Maurice Herlihy, et al] Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
30 Correctness and Progress Conditions Designing of any method or data-structure in the concurrent world, needs to satisfy these two properties: [Maurice Herlihy, et al] 1 Correctness and Safety: Linearizability Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
31 Correctness and Progress Conditions Designing of any method or data-structure in the concurrent world, needs to satisfy these two properties: [Maurice Herlihy, et al] 1 Correctness and Safety: Linearizability 2 Liveness: Progress Conditions Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
32 Outline of the Presentation 1 Motivation 2 Problem Definition 3 Our Methodology 4 Working of the methods 5 Correctness 6 Empirical Results 7 Conclusion & Future Work
33 Working of AddVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
34 Working of AddVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
35 Working of AddVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
36 Working of AddVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
37 Working of AddVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
38 Working of AddVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
39 Working of AddVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
40 Working of AddVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
41 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
42 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
43 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
44 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
45 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
46 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
47 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
48 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
49 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
50 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
51 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
52 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
53 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
54 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
55 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
56 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
57 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
58 Working of RemoveVertex(u) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
59 Working of RemoveEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
60 Working of RemoveEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
61 Working of RemoveEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
62 Working of RemoveEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
63 Working of RemoveEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
64 Working of RemoveEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
65 Working of RemoveEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
66 Working of RemoveEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
67 Working of RemoveEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
68 Working of AddEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
69 Working of AddEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
70 Working of AddEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
71 Working of AddEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
72 Working of AddEdge(u, v) method Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
73 Outline of the Presentation 1 Motivation 2 Problem Definition 3 Our Methodology 4 Working of the methods 5 Correctness 6 Empirical Results 7 Conclusion & Future Work
74 What is Linearizability? Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
75 What is Linearizability? A history is a sequence of invocations and responses made of an object by a set of threads. Each invocation of a function will have a subsequent response. A correctness condition for concurrent objects, by [Maurice Herlihy, et al.] Definition Each method call should appear to take effect instantaneously at some moment between its invocation and response. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
76 Linearizability Contd... A history is linearizable if: its invocations and responses can be reordered to yield a sequential history; Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
77 Linearizability Contd... A history is linearizable if: its invocations and responses can be reordered to yield a sequential history; that sequential history is correct according to the sequential definition of the object; Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
78 Linearizability Contd... A history is linearizable if: its invocations and responses can be reordered to yield a sequential history; that sequential history is correct according to the sequential definition of the object; if a response preceded an invocation in the original history, it must still precede it in the sequential reordering. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
79 Example of Linearizability Figure : An execution of Concurrent Blocking queue with its linearization points Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
80 Progress Guarantees Blocking: In this, an arbitrary and unexpected delay by any thread (say, one holding a lock) can prevent other threads from making progress. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
81 Progress Guarantees Blocking: In this, an arbitrary and unexpected delay by any thread (say, one holding a lock) can prevent other threads from making progress. Non-Blocking: This condition ensures that threads competing for a shared resource do not have their execution indefinitely postponed by mutual exclusion. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
82 Blocking Progress Guarantees Deadlock-free: A method is said to be deadlock-free, meaning that some thread trying to acquire the lock eventually succeeds. The system as a whole makes progress, but does not guarantee progress to individual threads. Weakest progress condition. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
83 Blocking Progress Guarantees Deadlock-free: A method is said to be deadlock-free, meaning that some thread trying to acquire the lock eventually succeeds. The system as a whole makes progress, but does not guarantee progress to individual threads. Weakest progress condition. Starvation-free: A method is starvation-free if every thread that attempts to acquire the lock eventually succeeds. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
84 Non-blocking Progress An algorithm is Non-blocking: If failure or suspension of any thread cannot cause failure or suspension of another thread, for some operations. A non-blocking algorithm can be Lock-free Wait-free Obstruction-free Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
85 Non-Blocking Progress Guarantees Contd.. Lock-freedom A method is lock-free if some thread that calls a method eventually returns. A lock-free data structure doesn t use any mutex locks. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
86 Non-Blocking Progress Guarantees Contd.. Lock-freedom A method is lock-free if some thread that calls a method eventually returns. A lock-free data structure doesn t use any mutex locks. Wait-freedom A method is wait-free if every thread that calls that method eventually returns in a finite number of its steps. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
87 Non-Blocking Progress Guarantees Contd.. Lock-freedom A method is lock-free if some thread that calls a method eventually returns. A lock-free data structure doesn t use any mutex locks. Wait-freedom A method is wait-free if every thread that calls that method eventually returns in a finite number of its steps. Obstruction-freedom A method is obstruction-free if every thread that calls that method returns if that thread executes in isolation for long enough. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
88 The Relationship among All Figure : The Periodic Table of Progress Conditions Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
89 Linearization Point of AddVertex(u) If the method returns successfully (true), 1 Point where new vertex node is reachable from the head Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
90 Linearization Point of AddVertex(u) If the method returns successfully (true), 1 Point where new vertex node is reachable from the head If the method returns unsuccessfully, 1 Point where a vertex node with same key is found in the vertex list Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
91 Linearization Point of RemoveVertex(u) If the method returns successfully (true), 1 Point where vertex node is logically marked as deleted Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
92 Linearization Point of RemoveVertex(u) If the method returns successfully (true), 1 Point where vertex node is logically marked as deleted If the method returns unsuccessfully, 1 Point where a vertex node with key to be deleted is not found in the vertex list Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
93 Linearization Point of ContainsVertex(u) Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
94 Linearization Point of AddEdge(u, v) If the method returns successfully (true), 1 If there is no concurrent successful DeleteVertex u & v, point where new edge node is logically added or already found 2 If concurrent successful DeleteVertex(u, v), then just before its LP. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
95 Linearization Point of AddEdge(u, v) If the method returns successfully (true), 1 If there is no concurrent successful DeleteVertex u & v, point where new edge node is logically added or already found 2 If concurrent successful DeleteVertex(u, v), then just before its LP. If the method returns unsuccessfully, 1 If there is no concurrent successful AddVertex u & v, LP is last of 1 Point if the vertex u is not found in the vertex list 2 Point if the vertex v is not found in the vertex list 3 Point if the edge v is not found in the edge list of u 2 If concurrent successful AddVertex u & v, then just before its LP. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
96 How to linearise concurrent methods? Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
97 Linearization Point of RemoveEdge(u, v) If the method returns successfully (true), 1 If there is no concurrent successful DeleteVertex u & v, point where new edge node is logically deleted 2 If concurrent successful DeleteVertex(u, v), then just before its LP. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
98 Linearization Point of RemoveEdge(u, v) If the method returns successfully (true), 1 If there is no concurrent successful DeleteVertex u & v, point where new edge node is logically deleted 2 If concurrent successful DeleteVertex(u, v), then just before its LP. If the method returns unsuccessfully, 1 If there is no concurrent successful AddVertex u & v, LP is last of 1 Line 9 if the vertex u is not found in the vertex list 2 Line 17 if the vertex v is not found in the vertex list 3 Line 30 if the edge v is not found in the edge list of u 2 If concurrent successful AddVertex u & v, then just before its LP. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
99 How to linearise concurrent methods? Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
100 How to linearise concurrent methods? Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
101 How to linearise concurrent methods? Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
102 How to linearise concurrent methods? Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
103 How to linearise concurrent methods? Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
104 Outline of the Presentation 1 Motivation 2 Problem Definition 3 Our Methodology 4 Working of the methods 5 Correctness 6 Empirical Results 7 Conclusion & Future Work
105 Experimental Setup 24 core Intel Xeon server running at 3.07 GHz core frequency Each core supports 6 hardware threads, clocked at 1600 MHz. Each thread randomly performs a set of operations chosen by a particular workload distribution. Each data point is obtained after averaging for 5 iterations. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
106 Results 1 Figure : AddE:50%, DelE: 50% and rest are 0% Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
107 Results 2 Figure : CV:15%, CE:15%, AddE:25%, DelE:10%, AddV:25% & DelV:10%. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
108 Results 3 Figure : CV:40%, CE:40%, AddE:7%, DelE:3%, AddV:7% & DelV:3% Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
109 Outline of the Presentation 1 Motivation 2 Problem Definition 3 Our Methodology 4 Working of the methods 5 Correctness 6 Empirical Results 7 Conclusion & Future Work
110 Conclusion - Presented generic constructuction of a fully dynamic concurrent graph data structure, which allows threads to concurrently add/delete vertices/edges. - We constructed it by the composition of the well-known concurrent list-based set data structure. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
111 Future Work 1 Using it for other parallel graph algorithms. 2 Currently working on Concurrent Serialization Graph Testing Scheduler. Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
112 Thank You! Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
113 For Further Reading.. Michael A. Bender, et al. A New Approach to Incremental Cycle Detection and Related Problems. ACM Transactions on Algorithms, Vol. 8, No. 1, Article 3, Publication date: January Maurice P. et al. Linearizability: A Correctness Condition for Concurrent Objects. ACM Transactions on Programming Languages and Systems, Vol. 12, No. 3, July 1990, Pages M. Herlihy. et al. Obstruction-free synchronization: double-ended queues as an example. Proc. IEEE ICDCS, , 2003 Y. Riany. et al. Towards a practical snapshot algorithm. Theoretical Computer Science, 269(1-2): , Maurice Herlihy and Nir Shavit. The Art of Multiprocesor Programming, Revised Print. Imprinted Morgan Kaufmann,Elsevier, May Peter S. Pacheco. An Introduction to Parallel Programming, 1st Edition. Imprinted Morgan Kaufmann,Elsevier, May Bernhard Haeupler Telikepalli Kavitha, Roger Mathew, Siddhartha Sen, and Robert E. Tarjan, Incremental cycle detection, toplogical ordering, and strong component maintenance. ACM Transactions on Algorithms, 8 (2012), pp. 3:13:33 A. Natarajan and N. Mittal, Fast concurrent lock-free binary search trees 19 th PPoPP, 2014, pp E. Szpilrajn Sur lextension de lordre partiel. Fundamenta Mathematicae, 16 (1930), pp D.J. Pearce, P.H.J. Kelly, and C. Hankin, Online cycle detection and difference propagation for pointer analysis Proceedings of the 3rd International Workshop on Source Code Analysis and Manipulation, Sept. 2003, pp. 312 Donald E. Knuth, The Art of Computer Programming, Volume 1: Fundamental Algorithms,Addison Wesley, Reading, MA, 2nd ed., A.B. Kahn, Topological sorting of large networks, Communications of the ACM, 5 (1962),pp Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
114 Questions? Concurrent Graph Data Structure IIT Hyderabad Jan 4, /48
Linked Lists: Locking, Lock-Free, and Beyond. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Linked Lists: Locking, Lock-Free, and Beyond Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Concurrent Objects Adding threads should not lower throughput Contention
Performance Comparison of Various STM Concurrency Control Protocols Using Synchrobench
Performance Comparison of Various STM Concurrency Control Protocols Using Synchrobench Ajay Singh Dr. Sathya Peri Anila Kumari Monika G. February 24, 2017 STM vs Synchrobench IIT Hyderabad February 24,
Linked Lists: Locking, Lock- Free, and Beyond. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Linked Lists: Locking, Lock- Free, and Beyond Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Coarse-Grained Synchronization Each method locks the object Avoid
Linked Lists: The Role of Locking. Erez Petrank Technion
Linked Lists: The Role of Locking Erez Petrank Technion Why Data Structures? Concurrent Data Structures are building blocks Used as libraries Construction principles apply broadly This Lecture Designing
Fast and Lock-Free Concurrent Priority Queues for Multi-Thread Systems
Fast and Lock-Free Concurrent Priority Queues for Multi-Thread Systems Håkan Sundell Philippas Tsigas Outline Synchronization Methods Priority Queues Concurrent Priority Queues Lock-Free Algorithm: Problems
Unit 6: Indeterminate Computation
Unit 6: Indeterminate Computation Martha A. Kim October 6, 2013 Introduction Until now, we have considered parallelizations of sequential programs. The parallelizations were deemed safe if the parallel
Lock-Free and Practical Doubly Linked List-Based Deques using Single-Word Compare-And-Swap
Lock-Free and Practical Doubly Linked List-Based Deques using Single-Word Compare-And-Swap Håkan Sundell Philippas Tsigas OPODIS 2004: The 8th International Conference on Principles of Distributed Systems
The Art of Multiprocessor Programming Copyright 2007 Elsevier Inc. All rights reserved. October 3, 2007 DRAFT COPY
The Art of Multiprocessor Programming Copyright 2007 Elsevier Inc. All rights reserved Maurice Herlihy October 3, 2007 Nir Shavit 2 Contents 1 Introduction 13 1.1 Shared Objects and Synchronization..............
Programming Paradigms for Concurrency Lecture 3 Concurrent Objects
Programming Paradigms for Concurrency Lecture 3 Concurrent Objects Based on companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Modified by Thomas Wies New York University
Concurrent Counting using Combining Tree
Final Project Report by Shang Wang, Taolun Chai and Xiaoming Jia Concurrent Counting using Combining Tree 1. Introduction Counting is one of the very basic and natural activities that computers do. However,
Solution: a lock (a/k/a mutex) public: virtual void unlock() =0;
1 Solution: a lock (a/k/a mutex) class BasicLock { public: virtual void lock() =0; virtual void unlock() =0; ; 2 Using a lock class Counter { public: int get_and_inc() { lock_.lock(); int old = count_;
Concurrent Skip Lists. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Concurrent Skip Lists Companion slides for The by Maurice Herlihy & Nir Shavit Set Object Interface Collection of elements No duplicates Methods add() a new element remove() an element contains() if element
Scheduling Transactions in Replicated Distributed Transactional Memory
Scheduling Transactions in Replicated Distributed Transactional Memory Junwhan Kim and Binoy Ravindran Virginia Tech USA {junwhan,binoy}@vt.edu CCGrid 2013 Concurrency control on chip multiprocessors significantly
1 The comparison of QC, SC and LIN
Com S 611 Spring Semester 2009 Algorithms for Multiprocessor Synchronization Lecture 5: Tuesday, 3rd February 2009 Instructor: Soma Chaudhuri Scribe: Jianrong Dong 1 The comparison of QC, SC and LIN Pi
Lock-free Serializable Transactions
Lock-free Serializable Transactions Jeff Napper jmn@cs.utexas.edu Lorenzo Alvisi lorenzo@cs.utexas.edu Laboratory for Advanced Systems Research Department of Computer Science The University of Texas at
What is the Race Condition? And what is its solution? What is a critical section? And what is the critical section problem?
What is the Race Condition? And what is its solution? Race Condition: Where several processes access and manipulate the same data concurrently and the outcome of the execution depends on the particular
A Skiplist-based Concurrent Priority Queue with Minimal Memory Contention
A Skiplist-based Concurrent Priority Queue with Minimal Memory Contention Jonatan Lindén and Bengt Jonsson Uppsala University, Sweden December 18, 2013 Jonatan Lindén 1 Contributions Motivation: Improve
Shared-Memory Computability
Shared-Memory Computability 10011 Universal Object Wait-free/Lock-free computable = Threads with methods that solve n- consensus Art of Multiprocessor Programming Copyright Herlihy- Shavit 2007 93 GetAndSet
Mutual Exclusion: Classical Algorithms for Locks
Mutual Exclusion: Classical Algorithms for Locks John Mellor-Crummey Department of Computer Science Rice University johnmc@cs.rice.edu COMP 422 Lecture 18 21 March 2006 Motivation Ensure that a block of
how to implement any concurrent data structure
how to implement any concurrent data structure marcos k. aguilera vmware jointly with irina calciu siddhartha sen mahesh balakrishnan Where to find more information about this work How to Implement Any
SSC - Concurrency and Multi-threading Java multithreading programming - Synchronisation (II)
SSC - Concurrency and Multi-threading Java multithreading programming - Synchronisation (II) Shan He School for Computational Science University of Birmingham Module 06-19321: SSC Outline Outline of Topics
Scalable GPU Graph Traversal!
Scalable GPU Graph Traversal Duane Merrill, Michael Garland, and Andrew Grimshaw PPoPP '12 Proceedings of the 17th ACM SIGPLAN symposium on Principles and Practice of Parallel Programming Benwen Zhang
6.852: Distributed Algorithms Fall, Class 20
6.852: Distributed Algorithms Fall, 2009 Class 20 Today s plan z z z Transactional Memory Reading: Herlihy-Shavit, Chapter 18 Guerraoui, Kapalka, Chapters 1-4 Next: z z z Asynchronous networks vs asynchronous
k-abortable Objects: Progress under High Contention
k-abortable Objects: Progress under High Contention Naama Ben-David 1, David Yu Cheng Chan 2, Vassos Hadzilacos 2, and Sam Toueg 2 Carnegie Mellon University 1 University of Toronto 2 Outline Background
Non-blocking Array-based Algorithms for Stacks and Queues. Niloufar Shafiei
Non-blocking Array-based Algorithms for Stacks and Queues Niloufar Shafiei Outline Introduction Concurrent stacks and queues Contributions New algorithms New algorithms using bounded counter values Correctness
A Simple Optimistic skip-list Algorithm
A Simple Optimistic skip-list Algorithm Maurice Herlihy Brown University & Sun Microsystems Laboratories Yossi Lev Brown University & Sun Microsystems Laboratories yosef.lev@sun.com Victor Luchangco Sun
Lock vs. Lock-free Memory Project proposal
Lock vs. Lock-free Memory Project proposal Fahad Alduraibi Aws Ahmad Eman Elrifaei Electrical and Computer Engineering Southern Illinois University 1. Introduction The CPU performance development history
Outline. Database Tuning. Ideal Transaction. Concurrency Tuning Goals. Concurrency Tuning. Nikolaus Augsten. Lock Tuning. Unit 8 WS 2013/2014
Outline Database Tuning Nikolaus Augsten University of Salzburg Department of Computer Science Database Group 1 Unit 8 WS 2013/2014 Adapted from Database Tuning by Dennis Shasha and Philippe Bonnet. Nikolaus
Implementing caches. Example. Client. N. America. Client System + Caches. Asia. Client. Africa. Client. Client. Client. Client. Client.
N. America Example Implementing caches Doug Woos Asia System + Caches Africa put (k2, g(get(k1)) put (k2, g(get(k1)) What if clients use a sharded key-value store to coordinate their output? Or CPUs use
PERFORMANCE ANALYSIS AND OPTIMIZATION OF SKIP LISTS FOR MODERN MULTI-CORE ARCHITECTURES
PERFORMANCE ANALYSIS AND OPTIMIZATION OF SKIP LISTS FOR MODERN MULTI-CORE ARCHITECTURES Anish Athalye and Patrick Long Mentors: Austin Clements and Stephen Tu 3 rd annual MIT PRIMES Conference Sequential
Database Management and Tuning
Database Management and Tuning Concurrency Tuning Johann Gamper Free University of Bozen-Bolzano Faculty of Computer Science IDSE Unit 8 May 10, 2012 Acknowledgements: The slides are provided by Nikolaus
Concurrent Objects. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Concurrent Objects Companion slides for The by Maurice Herlihy & Nir Shavit Concurrent Computation memory object object 2 Objectivism What is a concurrent object? How do we describe one? How do we implement
Linearizability of Persistent Memory Objects
Linearizability of Persistent Memory Objects Michael L. Scott Joint work with Joseph Izraelevitz & Hammurabi Mendes www.cs.rochester.edu/research/synchronization/ Workshop on the Theory of Transactional
Locking Granularity. CS 475, Spring 2019 Concurrent & Distributed Systems. With material from Herlihy & Shavit, Art of Multiprocessor Programming
Locking Granularity CS 475, Spring 2019 Concurrent & Distributed Systems With material from Herlihy & Shavit, Art of Multiprocessor Programming Discussion: HW1 Part 4 addtolist(key1, newvalue) Thread 1
Bw-Tree. Josef Schmeißer. January 9, Josef Schmeißer Bw-Tree January 9, / 25
Bw-Tree Josef Schmeißer January 9, 2018 Josef Schmeißer Bw-Tree January 9, 2018 1 / 25 Table of contents 1 Fundamentals 2 Tree Structure 3 Evaluation 4 Further Reading Josef Schmeißer Bw-Tree January 9,
From Lock-Free to Wait-Free: Linked List. Edward Duong
From Lock-Free to Wait-Free: Linked List Edward Duong Outline 1) Outline operations of the locality conscious linked list [Braginsky 2012] 2) Transformation concept from lock-free -> wait-free [Timnat
Parallel Programming Concepts. Parallel Algorithms. Peter Tröger
Parallel Programming Concepts Parallel Algorithms Peter Tröger Sources: Ian Foster. Designing and Building Parallel Programs. Addison-Wesley. 1995. Mattson, Timothy G.; S, Beverly A.; ers,; Massingill,
Whatever can go wrong will go wrong. attributed to Edward A. Murphy. Murphy was an optimist. authors of lock-free programs 3.
Whatever can go wrong will go wrong. attributed to Edward A. Murphy Murphy was an optimist. authors of lock-free programs 3. LOCK FREE KERNEL 309 Literature Maurice Herlihy and Nir Shavit. The Art of Multiprocessor
Multi-Core Computing with Transactional Memory. Johannes Schneider and Prof. Roger Wattenhofer
Multi-Core Computing with Transactional Memory Johannes Schneider and Prof. Roger Wattenhofer 1 Overview Introduction Difficulties with parallel (multi-core) programming A (partial) solution: Transactional
Cache-Aware Lock-Free Queues for Multiple Producers/Consumers and Weak Memory Consistency
Cache-Aware Lock-Free Queues for Multiple Producers/Consumers and Weak Memory Consistency Anders Gidenstam Håkan Sundell Philippas Tsigas School of business and informatics University of Borås Distributed
Concurrent Systems. XIII. Progress Guarantee. Wolfgang Schröder-Preikschat. Selbststudium. Nebenläufige Systeme
Concurrent Systems Nebenläufige Systeme XIII. Progress Guarantee Wolfgang Schröder-Preikschat Selbststudium Agenda In a Nutshell wosch CS ( Selbststudium ) In a Nutshell 2 Outline In a Nutshell wosch CS
A Concurrent Skip List Implementation with RTM and HLE
A Concurrent Skip List Implementation with RTM and HLE Fan Gao May 14, 2014 1 Background Semester Performed: Spring, 2014 Instructor: Maurice Herlihy The main idea of my project is to implement a skip
Non-blocking Array-based Algorithms for Stacks and Queues!
Non-blocking Array-based Algorithms for Stacks and Queues! Niloufar Shafiei! Department of Computer Science and Engineering York University ICDCN 09 Outline! Introduction! Stack algorithm! Queue algorithm!
Concurrent Objects and Linearizability
Chapter 3 Concurrent Objects and Linearizability 3.1 Specifying Objects An object in languages such as Java and C++ is a container for data. Each object provides a set of methods that are the only way
CS420: Operating Systems. Process Synchronization
Process Synchronization James Moscola Department of Engineering & Computer Science York College of Pennsylvania Based on Operating System Concepts, 9th Edition by Silberschatz, Galvin, Gagne Background
arxiv: v1 [cs.dc] 8 May 2017
![arxiv: v1 [cs.dc] 8 May 2017](/thumbs/81/82817673.jpg "arxiv: v1 [cs.dc] 8 May 2017")
Towards Reduced Instruction Sets for Synchronization arxiv:1705.02808v1 [cs.dc] 8 May 2017 Rati Gelashvili MIT gelash@mit.edu Alexander Spiegelman Technion sashas@tx.technion.ac.il Idit Keidar Technion
Enhancing Concurrency in Distributed Transactional Memory through Commutativity
Enhancing Concurrency in Distributed Transactional Memory through Commutativity Junwhan Kim, Roberto Palmieri, Binoy Ravindran Virginia Tech USA Lock-based concurrency control has serious drawbacks Coarse
Concurrent Preliminaries
Concurrent Preliminaries Sagi Katorza Tel Aviv University 09/12/2014 1 Outline Hardware infrastructure Hardware primitives Mutual exclusion Work sharing and termination detection Concurrent data structures
Brushing the Locks out of the Fur: A Lock-Free Work Stealing Library Based on Wool
Brushing the Locks out of the Fur: A Lock-Free Work Stealing Library Based on Wool Håkan Sundell School of Business and Informatics University of Borås, 50 90 Borås E-mail: Hakan.Sundell@hb.se Philippas
Coordination and Agreement
Coordination and Agreement Nicola Dragoni Embedded Systems Engineering DTU Informatics 1. Introduction 2. Distributed Mutual Exclusion 3. Elections 4. Multicast Communication 5. Consensus and related problems
Linked Lists: Locking, Lock- Free, and Beyond. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Linked Lists: Locking, Lock- Free, and Beyond Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Last Lecture: Spin-Locks CS. spin lock critical section Resets lock
Transactional Memory. Concurrency unlocked Programming. Bingsheng Wang TM Operating Systems
Concurrency unlocked Programming Bingsheng Wang TM Operating Systems 1 Outline Background Motivation Database Transaction Transactional Memory History Transactional Memory Example Mechanisms Software Transactional
Models of concurrency & synchronization algorithms
Models of concurrency & synchronization algorithms Lecture 3 of TDA383/DIT390 (Concurrent Programming) Carlo A. Furia Chalmers University of Technology University of Gothenburg SP3 2016/2017 Today s menu
Process Synchronisation (contd.) Operating Systems. Autumn CS4023
Operating Systems Autumn 2017-2018 Outline Process Synchronisation (contd.) 1 Process Synchronisation (contd.) Synchronization Hardware 6.4 (SGG) Many systems provide hardware support for critical section
CS377P Programming for Performance Multicore Performance Synchronization
CS377P Programming for Performance Multicore Performance Synchronization Sreepathi Pai UTCS October 21, 2015 Outline 1 Synchronization Primitives 2 Blocking, Lock-free and Wait-free Algorithms 3 Transactional
Software transactional memory
Transactional locking II (Dice et. al, DISC'06) Time-based STM (Felber et. al, TPDS'08) Mentor: Johannes Schneider March 16 th, 2011 Motivation Multiprocessor systems Speed up time-sharing applications
Introduction to Concurrency and Multicore Programming. Slides adapted from Art of Multicore Programming by Herlihy and Shavit
Introduction to Concurrency and Multicore Programming Slides adapted from Art of Multicore Programming by Herlihy and Shavit Overview Introduction Mutual Exclusion Linearizability Concurrent Data Structure
PROCESS SYNCHRONIZATION
PROCESS SYNCHRONIZATION Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization Monitors Synchronization
Whatever can go wrong will go wrong. attributed to Edward A. Murphy. Murphy was an optimist. authors of lock-free programs LOCK FREE KERNEL
Whatever can go wrong will go wrong. attributed to Edward A. Murphy Murphy was an optimist. authors of lock-free programs LOCK FREE KERNEL 251 Literature Maurice Herlihy and Nir Shavit. The Art of Multiprocessor
Concurrency Issues. Past lectures: What about coordinated access across multiple objects? Today s lecture:
Deadlock 1 Concurrency Issues Past lectures: Ø Problem: Safely coordinate access to shared resource Ø Solutions: Use semaphores, monitors, locks, condition variables Coordinate access within shared objects
DISTRIBUTED MUTEX. EE324 Lecture 11
DISTRIBUTED MUTEX EE324 Lecture 11 Vector Clocks Vector clocks overcome the shortcoming of Lamport logical clocks L(e) < L(e ) does not imply e happened before e Goal Want ordering that matches causality
Advance Operating Systems (CS202) Locks Discussion
Advance Operating Systems (CS202) Locks Discussion Threads Locks Spin Locks Array-based Locks MCS Locks Sequential Locks Road Map Threads Global variables and static objects are shared Stored in the static
Reagent Based Lock Free Concurrent Link List Spring 2012 Ancsa Hannak and Mitesh Jain April 28, 2012
Reagent Based Lock Free Concurrent Link List Spring 0 Ancsa Hannak and Mitesh Jain April 8, 0 Introduction The most commonly used implementation of synchronization is blocking algorithms. They utilize
Synchronization for Concurrent Tasks
Synchronization for Concurrent Tasks Minsoo Ryu Department of Computer Science and Engineering 2 1 Race Condition and Critical Section Page X 2 Algorithmic Approaches Page X 3 Hardware Support Page X 4
Ownership of a queue for practical lock-free scheduling
Ownership of a queue for practical lock-free scheduling Lincoln Quirk May 4, 2008 Abstract We consider the problem of scheduling tasks in a multiprocessor. Tasks cannot always be scheduled independently
Chapter 6: Process Synchronization
Chapter 6: Process Synchronization Objectives Introduce Concept of Critical-Section Problem Hardware and Software Solutions of Critical-Section Problem Concept of Atomic Transaction Operating Systems CS
Adaptive Lock. Madhav Iyengar < >, Nathaniel Jeffries < >
Adaptive Lock Madhav Iyengar < miyengar@andrew.cmu.edu >, Nathaniel Jeffries < njeffrie@andrew.cmu.edu > ABSTRACT Busy wait synchronization, the spinlock, is the primitive at the core of all other synchronization
The University of Texas at Arlington
The University of Texas at Arlington Lecture 6: Threading and Parallel Programming Constraints CSE 5343/4342 Embedded Systems II Based heavily on slides by Dr. Roger Walker More Task Decomposition: Dependence
Self Stabilization. CS553 Distributed Algorithms Prof. Ajay Kshemkalyani. by Islam Ismailov & Mohamed M. Ali
Self Stabilization CS553 Distributed Algorithms Prof. Ajay Kshemkalyani by Islam Ismailov & Mohamed M. Ali Introduction There is a possibility for a distributed system to go into an illegitimate state,
Linearizability of Persistent Memory Objects
Linearizability of Persistent Memory Objects Michael L. Scott Joint work with Joseph Izraelevitz & Hammurabi Mendes www.cs.rochester.edu/research/synchronization/ Compiler-Driven Performance Workshop,
Split-Ordered Lists: Lock-Free Extensible Hash Tables. Pierre LaBorde
1 Split-Ordered Lists: Lock-Free Extensible Hash Tables Pierre LaBorde Nir Shavit 2 Tel-Aviv University, Israel Ph.D. from Hebrew University Professor at School of Computer Science at Tel-Aviv University
Programming Paradigms for Concurrency Lecture 6 Synchronization of Concurrent Objects
Programming Paradigms for Concurrency Lecture 6 Synchronization of Concurrent Objects Based on companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Modified by Thomas
CS 31: Introduction to Computer Systems : Threads & Synchronization April 16-18, 2019
CS 31: Introduction to Computer Systems 22-23: Threads & Synchronization April 16-18, 2019 Making Programs Run Faster We all like how fast computers are In the old days (1980 s - 2005): Algorithm too slow?
Multiprocessor Systems. Chapter 8, 8.1
Multiprocessor Systems Chapter 8, 8.1 1 Learning Outcomes An understanding of the structure and limits of multiprocessor hardware. An appreciation of approaches to operating system support for multiprocessor
A Concurrent Bidirectional Linear Probing Algorithm
A Concurrent Bidirectional Linear Probing Algorithm Towards a Concurrent Compact Hash Table Steven van der Vegt University of Twente The Netherlands s.vandervegt@student.utwente.nl ABSTRACT Hash tables
Transactional Memory: Architectural Support for Lock-Free Data Structures Maurice Herlihy and J. Eliot B. Moss ISCA 93
Transactional Memory: Architectural Support for Lock-Free Data Structures Maurice Herlihy and J. Eliot B. Moss ISCA 93 What are lock-free data structures A shared data structure is lock-free if its operations
Linearizable Iterators
Linearizable Iterators Supervised by Maurice Herlihy Abstract Petrank et. al. [5] provide a construction of lock-free, linearizable iterators for lock-free linked lists. We consider the problem of extending
Lecture: Consistency Models, TM. Topics: consistency models, TM intro (Section 5.6)
Lecture: Consistency Models, TM Topics: consistency models, TM intro (Section 5.6) 1 Coherence Vs. Consistency Recall that coherence guarantees (i) that a write will eventually be seen by other processors,
Parallel Programming Programowanie równoległe
Parallel Programming Programowanie równoległe Lecture 1: Introduction. Basic notions of parallel processing Paweł Rzążewski Grading laboratories (4 tasks, each for 3-4 weeks) total 50 points, final test
Shared Objects. Shared Objects
Shared Objects Shared Objects Invoked operations have a non-zero duration Invocations can overlap Useful for: modeling distributed shared memory Objects can be combined together to implement higher level
Binary Decision Diagrams and Symbolic Model Checking
Binary Decision Diagrams and Symbolic Model Checking Randy Bryant Ed Clarke Ken McMillan Allen Emerson CMU CMU Cadence U Texas http://www.cs.cmu.edu/~bryant Binary Decision Diagrams Restricted Form of
AST: scalable synchronization Supervisors guide 2002
AST: scalable synchronization Supervisors guide 00 tim.harris@cl.cam.ac.uk These are some notes about the topics that I intended the questions to draw on. Do let me know if you find the questions unclear
Overview of Lecture 4. Memory Models, Atomicity & Performance. Ben-Ari Concurrency Model. Dekker s Algorithm 4
Concurrent and Distributed Programming http://fmt.cs.utwente.nl/courses/cdp/ Overview of Lecture 4 2 Memory Models, tomicity & Performance HC 4 - Tuesday, 6 December 2011 http://fmt.cs.utwente.nl/~marieke/
Safety and liveness for critical sections
Safety and liveness for critical sections! At most k threads are concurrently in the critical section A. Safety B. Liveness C. Both! A thread that wants to enter the critical section will eventually succeed
Last Lecture: Spin-Locks
Linked Lists: Locking, Lock- Free, and Beyond Last Lecture: Spin-Locks. spin lock CS critical section Resets lock upon exit Today: Concurrent Objects Adding threads should not lower throughput Contention
DESIGN CHALLENGES FOR SCALABLE CONCURRENT DATA STRUCTURES for Many-Core Processors
DESIGN CHALLENGES FOR SCALABLE CONCURRENT DATA STRUCTURES for Many-Core Processors DIMACS March 15 th, 2011 Philippas Tsigas Data Structures In Manycore Sys. Decomposition Synchronization Load Balancing
Concurrency: a crash course
Chair of Software Engineering Carlo A. Furia, Marco Piccioni, Bertrand Meyer Concurrency: a crash course Concurrent computing Applications designed as a collection of computational units that may execute
Important Lessons. A Distributed Algorithm (2) Today's Lecture - Replication
Important Lessons Lamport & vector clocks both give a logical timestamps Total ordering vs. causal ordering Other issues in coordinating node activities Exclusive access to resources/data Choosing a single
The Complexity of Renaming
The Complexity of Renaming Dan Alistarh EPFL James Aspnes Yale Seth Gilbert NUS Rachid Guerraoui EPFL Abstract We study the complexity of renaming, a fundamental problem in distributed computing in which
Lock Oscillation: Boosting the Performance of Concurrent Data Structures
Lock Oscillation: Boosting the Performance of Concurrent Data Structures Panagiota Fatourou FORTH ICS & University of Crete Nikolaos D. Kallimanis FORTH ICS The Multicore Era The dominance of Multicore
CPSC/ECE 3220 Fall 2017 Exam Give the definition (note: not the roles) for an operating system as stated in the textbook. (2 pts.
CPSC/ECE 3220 Fall 2017 Exam 1 Name: 1. Give the definition (note: not the roles) for an operating system as stated in the textbook. (2 pts.) Referee / Illusionist / Glue. Circle only one of R, I, or G.
Programming Languages
TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Programming Languages Concurrency: Atomic Executions, Locks and Monitors Dr. Michael Petter Winter term 2016 Atomic Executions, Locks and Monitors
CSE 451: Operating Systems Winter Lecture 7 Synchronization. Steve Gribble. Synchronization. Threads cooperate in multithreaded programs
CSE 451: Operating Systems Winter 2005 Lecture 7 Synchronization Steve Gribble Synchronization Threads cooperate in multithreaded programs to share resources, access shared data structures e.g., threads
Håkan Sundell University College of Borås Parallel Scalable Solutions AB
Brushing the Locks out of the Fur: A Lock-Free Work Stealing Library Based on Wool Håkan Sundell University College of Borås Parallel Scalable Solutions AB Philippas Tsigas Chalmers University of Technology
An Update on Haskell H/STM 1
An Update on Haskell H/STM 1 Ryan Yates and Michael L. Scott University of Rochester TRANSACT 10, 6-15-2015 1 This work was funded in part by the National Science Foundation under grants CCR-0963759, CCF-1116055,
NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY. Tim Harris, 28 November 2014
NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY Tim Harris, 28 November 2014 Lecture 8 Problems with locks Atomic blocks and composition Hardware transactional memory Software transactional memory
A Non-Blocking Concurrent Queue Algorithm
A Non-Blocking Concurrent Queue Algorithm Bruno Didot bruno.didot@epfl.ch June 2012 Abstract This report presents a new non-blocking concurrent FIFO queue backed by an unrolled linked list. Enqueue and
Introduction. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Introduction Companion slides for The by Maurice Herlihy & Nir Shavit Moore s Law Transistor count still rising Clock speed flattening sharply 2 Moore s Law (in practice) 3 Nearly Extinct: the Uniprocesor
G52CON: Concepts of Concurrency
G52CON: Concepts of Concurrency Lecture 6: Algorithms for Mutual Natasha Alechina School of Computer Science nza@cs.nott.ac.uk Outline of this lecture mutual exclusion with standard instructions example:
Optimization of thread affinity and memory affinity for remote core locking synchronization in multithreaded programs for multicore computer systems
Optimization of thread affinity and memory affinity for remote core locking synchronization in multithreaded programs for multicore computer systems Alexey Paznikov Saint Petersburg Electrotechnical University