Split-Ordered Lists: Lock-Free Extensible Hash Tables. Pierre LaBorde

Save this PDF as:
 WORD  PNG  TXT  JPG

Size: px
Start display at page:

Download "Split-Ordered Lists: Lock-Free Extensible Hash Tables. Pierre LaBorde"

Transcription

1 1 Split-Ordered Lists: Lock-Free Extensible Hash Tables Pierre LaBorde

2 Nir Shavit 2 Tel-Aviv University, Israel Ph.D. from Hebrew University Professor at School of Computer Science at Tel-Aviv University in Gödel Prize Winner The Art of Multiprocessor Programming

3 Outline 3 Hashing Concurrency Algorithm Implementation Performance

4 Hash Table 4 Map keys to values Map each possible key to a unique slot index Hash collisions are normal Constant average cost per operation Efficient

5 Hash Table 5 Name Phone Number

6 Collision Resolution 6 Bucket Chains sorted by the key field Disadvantages of linked lists Next pointer overhead Processor Cache

7 Chained Hashing 7

8 Extensible Hash Table 8 Treats a hash as a bit string Soft real-time Array of buckets Only increase in size

9 Outline 9 Hashing Concurrency Algorithm Implementation Performance

10 Concurrent Hash Table 10 Operations Insert Delete Find Ability to synchronize

11 Synchronization 11 Critical section Race condition Locking Mutex

12 Lock-Free 12 At least one thread will progress Wait-freedom General design problems Long delays Waiting for locks

13 Difficulty 13 Synchronization problems Deadlock Livelock Starvation Priority Inversion

14 Avoiding Locks 14 CAS LL/SC Single-word Hardware locks Fine-granularity

15 Resizing Problem 15 Requires moving items Atomic Other options Helping

16 Lock-Free Linked List 16 Validity Mark for Deletion Bit stealing Same CAS Straightforward implementation

17 Michael s Lock-Free LL 17 struct MarkPtrType { <mark, next>: <bool, NodeType *> }; struct NodeType { key_t key; MarkPtrType <mark, next>; }; /* thread-private variables */ MarkPtrType *prev; MarkPtrType <pmark, cur>; MarkPtrType <cmark, next>;

18 List: Find int list_find(nodetype **head, so_key_t key) { F1: try_again: F2: prev = head; F3: <pmark,cur> = *prev; F4: while(1) { F5: if (cur == NULL) return 0; F6: <cmark,next> = cur-><mark,next>; F7: ckey = cur->key; F8: if (*prev!= <0,cur>) F9: goto try_again; F10: if (!cmark) { F11: if (ckey >= key) F12: return ckey == key; F13: prev = &(cur-><mark,next>); } F14: else { F15: if (CAS(prev, <0,cur>, <0,next>)) F16: delete_node(cur); F17: else goto try_again; } F18: <pmark,cur> = <cmark,next>; } } 18

19 List: Insert 19 int list_insert(markptrtype *head, NodeType *node) { key = node->key; while (1) { if (list_find(head, key) return 0; node-><mark,next> = <0,cur>; if (CAS(prev, <0,cur>, <0,node>)) return 1; } }

20 List: Delete 20 int list_delete(markptrtype *head, so_key_t key) { while (1) { if (!list_find(head, key)) return 0; if (!CAS(&(cur-><mark,next>), <0,next>, <1,next>)) continue; if (CAS(prev, <0,cur>, <0,next>)) delete_node(cur); else list_find(head, key); return 1; } }

21 Outline 21 Hashing Concurrency Algorithm Implementation Performance

22 Algorithm 22 Split-ordering Avoid resizing problem "moving the buckets among the items

23 Resizing Revisited 23 Moving an item Ability to split sublists recursively Recursive split-ordering

24 Split-Ordered Hash Table 24

25 Split-Ordered Hash Table 25

26 Split-Ordered Hash Table 26

27 Split-Ordered Hash Table 27

28 Insertion 28

29 Insertion 29

30 Insertion 30

31 Insertion 31

32 Operations 32 Hash to bucket using split-ordering Follow pointer Traverse list

33 Split-Ordered Hash Table 33

34 Outline 34 Hashing Concurrency Algorithm Implementation Performance

35 Implementation 35 Modular design Michael s Lock-Free lists Memory management

36 Fetch and Increment 36 int fetch-and-inc(int *p) { do { old = *p; } while (!CAS(p, old, old+1); return old; } int fetch-and-dec(int *p) { do { old = *p; } while (!CAS(p, old, old-1); return old; }

37 Hash Table: Initialize Bucket 37 void initialize_bucket(uint bucket) { B1: parent = GET_PARENT(bucket); B2: if (T[parent] == UNINITIALIZED) B3: initialize_bucket(parent); B4: dummy = new node(so_dummykey(bucket)); B5: if (!list_insert(&(t[parent]), dummy)) { B6: delete dummy; B7: dummy = cur; } B8: T[bucket] = dummy; }

38 Hash Table: Insert 38 int insert(so_key_t key) { I1: node = new node(so_regularkey(key)); I2: bucket = key % size; I3: if (T[bucket] == UNINITIALIZED) I4: initialize_bucket(bucket); I5: if (!list_insert(&(t[bucket]), node)) { I6: delete_node(node); I7: return 0; } I8: csize = size; I9: if (fetch-and-inc(&count) / csize > MAX_LOAD) I10: CAS(&size, csize, 2 * csize); I11:return 1;}

39 Hash Table: Find 39 int find(so_key_t key) { S1: bucket = key % size; S2: if (T[bucket] == UNINITIALIZED) S3: initialize_bucket(bucket); S4: return list_find(&(t[bucket]), so_regularkey(key)); }

40 Hash Table: Delete 40 int delete(so_key_t key) { D1: bucket = key % size; D2: if (T[bucket] == UNINITIALIZED) D3: initialize_bucket(bucket); D4: if (!list_delete(&(t[bucket]), so_regularkey(key))) D5: return 0; D6: fetch-and-dec(&count); D7: return 1; }

41 Complexity 41 Distribution of keys Scheduling of threads

42 Outline 42 Hashing Concurrency Algorithm Implementation Performance

43 Throughput 43

44 Varying Preinsertions 44

45 Conclusion 45 Robustness with a non-uniform hash function Performance loss Low-load non-multiprogrammed Medium to high load

46 Bibliography 46 Split-Ordered Lists: Lock-Free Extensible Hash Tables The Art of Multiprocessor Programming Wikipedia

47 47 Split-Ordered Lists: Lock-Free Extensible Hash Tables Pierre LaBorde

48 48

49 Extendible Hashing for Concurrent Operations and Distributed Data 49

50 After Splitting 10 b bucket 50

51 Locks 51

52 52

53 53

54 54

55 55

56 56

Fine-grained synchronization & lock-free programming

Fine-grained synchronization & lock-free programming Lecture 17: Fine-grained synchronization & lock-free programming Parallel Computer Architecture and Programming CMU 15-418/15-618, Spring 2016 Tunes Minnie the Moocher Robbie Williams (Swings Both Ways)

More information

Hopscotch Hashing. 1 Introduction. Maurice Herlihy 1, Nir Shavit 2,3, and Moran Tzafrir 3

Hopscotch Hashing. 1 Introduction. Maurice Herlihy 1, Nir Shavit 2,3, and Moran Tzafrir 3 Hopscotch Hashing Maurice Herlihy 1, Nir Shavit 2,3, and Moran Tzafrir 3 1 Brown University, Providence, RI 2 Sun Microsystems, Burlington, MA 3 Tel-Aviv University, Tel-Aviv, Israel Abstract. We present

More information

Solution: a lock (a/k/a mutex) public: virtual void unlock() =0;

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_;

More information

CBPQ: High Performance Lock-Free Priority Queue

CBPQ: High Performance Lock-Free Priority Queue CBPQ: High Performance Lock-Free Priority Queue Anastasia Braginsky 1, Nachshon Cohen 2, and Erez Petrank 2 1 Yahoo! Labs Haifa anastas@yahoo-inc.com 2 Technion - Israel Institute of Technology {ncohen,erez}@cs.technion.ac.il

More information

Process Synchronisation (contd.) Operating Systems. Autumn CS4023

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

More information

Fast and Lock-Free Concurrent Priority Queues for Multi-Thread Systems

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

More information

Lecture 10: Multi-Object Synchronization

Lecture 10: Multi-Object Synchronization CS 422/522 Design & Implementation of Operating Systems Lecture 10: Multi-Object Synchronization Zhong Shao Dept. of Computer Science Yale University Acknowledgement: some slides are taken from previous

More information

Lock-Free Concurrent Data Structures, CAS and the ABA-Problem

Lock-Free Concurrent Data Structures, CAS and the ABA-Problem Lock-Free Concurrent Data Structures, CAS and the ABA-Problem 2 Motivation Today almost all PCs and Laptops have a multi-core ( e.g. quad-core ) processor Dr. Wolfgang Koch using SMP (symmetric multiprocessing)

More information

MemC3: MemCache with CLOCK and Concurrent Cuckoo Hashing

MemC3: MemCache with CLOCK and Concurrent Cuckoo Hashing MemC3: MemCache with CLOCK and Concurrent Cuckoo Hashing Bin Fan (CMU), Dave Andersen (CMU), Michael Kaminsky (Intel Labs) NSDI 2013 http://www.pdl.cmu.edu/ 1 Goal: Improve Memcached 1. Reduce space overhead

More information

List: Tree: Students are expected to pay attention and fill in the details. Fundamental dynamic memory structure is: list

List: Tree: Students are expected to pay attention and fill in the details. Fundamental dynamic memory structure is: list This is an outline of the lecture that is intended to provide you with the images and code. It is not a tutorial. Students are expected to pay attention and fill in the details. Fundamental dynamic memory

More information

Scalable Concurrent Hash Tables via Relativistic Programming

Scalable Concurrent Hash Tables via Relativistic Programming Scalable Concurrent Hash Tables via Relativistic Programming Josh Triplett September 24, 2009 Speed of data < Speed of light Speed of light: 3e8 meters/second Processor speed: 3 GHz, 3e9 cycles/second

More information

Locks and semaphores. Johan Montelius KTH

Locks and semaphores. Johan Montelius KTH Locks and semaphores Johan Montelius KTH 2017 1 / 41 recap, what s the problem : # include < pthread.h> volatile int count = 0; void * hello ( void * arg ) { for ( int i = 0; i < 10; i ++) { count ++;

More information

A Qualitative Survey of Modern Software Transactional Memory Systems

A Qualitative Survey of Modern Software Transactional Memory Systems A Qualitative Survey of Modern Software Transactional Memory Systems Virendra J. Marathe and Michael L. Scott TR 839 Department of Computer Science University of Rochester Rochester, NY 14627-0226 {vmarathe,

More information

Advance Operating Systems (CS202) Locks Discussion

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

More information

CS 333 Introduction to Operating Systems. Class 3 Threads & Concurrency. Jonathan Walpole Computer Science Portland State University

CS 333 Introduction to Operating Systems. Class 3 Threads & Concurrency. Jonathan Walpole Computer Science Portland State University CS 333 Introduction to Operating Systems Class 3 Threads & Concurrency Jonathan Walpole Computer Science Portland State University 1 Process creation in UNIX All processes have a unique process id getpid(),

More information

Concurrency, Thread. Dongkun Shin, SKKU

Concurrency, Thread. Dongkun Shin, SKKU Concurrency, Thread 1 Thread Classic view a single point of execution within a program a single PC where instructions are being fetched from and executed), Multi-threaded program Has more than one point

More information

Last Class: Synchronization

Last Class: Synchronization Last Class: Synchronization Synchronization primitives are required to ensure that only one thread executes in a critical section at a time. Concurrent programs Low-level atomic operations (hardware) load/store

More information

CS420: Operating Systems. Process Synchronization

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

More information

Non-blocking Array-based Algorithms for Stacks and Queues!

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!

More information

Concurrent Data Structures

Concurrent Data Structures Concurrent Data Structures Chapter 8 Roger Wattenhofer ETH Zurich Distributed Computing www.disco.ethz.ch Overview Concurrent Linked List Fine-grained synchronization Optimistic synchronization Lazy synchronization

More information

An Update on Haskell H/STM 1

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,

More information

Synchronization I. Jo, Heeseung

Synchronization I. Jo, Heeseung Synchronization I Jo, Heeseung Today's Topics Synchronization problem Locks 2 Synchronization Threads cooperate in multithreaded programs To share resources, access shared data structures Also, to coordinate

More information

Concurrent Systems. XIII. Progress Guarantee. Wolfgang Schröder-Preikschat. Selbststudium. Nebenläufige Systeme

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

More information

Concurrency in Java Prof. Stephen A. Edwards

Concurrency in Java Prof. Stephen A. Edwards Concurrency in Java Prof. Stephen A. Edwards The Java Language Developed by James Gosling et al. at Sun Microsystems in the early 1990s Originally called Oak, first intended application was as an OS for

More information

Atomicity CS 2110 Fall 2017

Atomicity CS 2110 Fall 2017 Atomicity CS 2110 Fall 2017 Parallel Programming Thus Far Parallel programs can be faster and more efficient Problem: race conditions Solution: synchronization Are there more efficient ways to ensure the

More information

Operating Systems. Designed and Presented by Dr. Ayman Elshenawy Elsefy

Operating Systems. Designed and Presented by Dr. Ayman Elshenawy Elsefy Operating Systems Designed and Presented by Dr. Ayman Elshenawy Elsefy Dept. of Systems & Computer Eng.. AL-AZHAR University Website : eaymanelshenawy.wordpress.com Email : eaymanelshenawy@yahoo.com Reference

More information

Software transactional memory

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

More information

Chapter 6: Synchronization. Operating System Concepts 8 th Edition,

Chapter 6: Synchronization. Operating System Concepts 8 th Edition, Chapter 6: Synchronization, Silberschatz, Galvin and Gagne 2009 Outline Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization

More information

Classical concurrency control: topic overview 1 In these lectures we consider shared writeable data in main memory

Classical concurrency control: topic overview 1 In these lectures we consider shared writeable data in main memory Classical concurrency control: topic overview 1 In these lectures we consider shared writeable data in main memory Controlling access by concurrent processes to shared writeable data has been studied as

More information

Introduction to PThreads and Basic Synchronization

Introduction to PThreads and Basic Synchronization Introduction to PThreads and Basic Synchronization Michael Jantz, Dr. Prasad Kulkarni Dr. Douglas Niehaus EECS 678 Pthreads Introduction Lab 1 Introduction In this lab, we will learn about some basic synchronization

More information

CSE 332: Locks and Deadlocks. Richard Anderson, Steve Seitz Winter 2014

CSE 332: Locks and Deadlocks. Richard Anderson, Steve Seitz Winter 2014 CSE 332: Locks and Deadlocks Richard Anderson, Steve Seitz Winter 2014 1 Recall Bank Account Problem class BankAccount { private int balance = 0; synchronized int getbalance() { return balance; } synchronized

More information

Bill Bridge. Oracle Software Architect NVM support for C Applications

Bill Bridge. Oracle Software Architect NVM support for C Applications JANUARY 20, 2015, SAN JOSE, CA Bill Bridge PRESENTATION TITLE GOES HERE Place Speaker Photo Here if Available Oracle Software Architect NVM support for C Applications Overview Oracle has developed a NVM

More information

Case Study: Using Inspect to Verify and fix bugs in a Work Stealing Deque Simulator

Case Study: Using Inspect to Verify and fix bugs in a Work Stealing Deque Simulator Case Study: Using Inspect to Verify and fix bugs in a Work Stealing Deque Simulator Wei-Fan Chiang 1 Introduction Writing bug-free multi-threaded programs is hard. Bugs in these programs have various types

More information

Interprocess Communication By: Kaushik Vaghani

Interprocess Communication By: Kaushik Vaghani Interprocess Communication By: Kaushik Vaghani Background Race Condition: A situation where several processes access and manipulate the same data concurrently and the outcome of execution depends on the

More information

a) Do exercise (5th Edition Patterson & Hennessy). Note: Branches are calculated in the execution stage.

a) Do exercise (5th Edition Patterson & Hennessy). Note: Branches are calculated in the execution stage. CS3410 Spring 2015 Problem Set 2 (version 3) Due Saturday, April 25, 11:59 PM (Due date for Problem-5 is April 20, 11:59 PM) NetID: Name: 200 points total. Start early! This is a big problem set. Problem

More information

Processor speed. Concurrency Structure and Interpretation of Computer Programs. Multiple processors. Processor speed. Mike Phillips <mpp>

Processor speed. Concurrency Structure and Interpretation of Computer Programs. Multiple processors. Processor speed. Mike Phillips <mpp> Processor speed 6.037 - Structure and Interpretation of Computer Programs Mike Phillips Massachusetts Institute of Technology http://en.wikipedia.org/wiki/file:transistor_count_and_moore%27s_law_-

More information

Introduction to Lock-Free Programming. Olivier Goffart

Introduction to Lock-Free Programming. Olivier Goffart Introduction to Lock-Free Programming Olivier Goffart 2014 QStyleSheetStyle Itemviews Animation Framework QtScript (porting to JSC and V8) QObject, moc QML Debugger Modularisation... About Me About Me

More information

NUMA-Aware Reader-Writer Locks PPoPP 2013

NUMA-Aware Reader-Writer Locks PPoPP 2013 NUMA-Aware Reader-Writer Locks PPoPP 2013 Irina Calciu Brown University Authors Irina Calciu @ Brown University Dave Dice Yossi Lev Victor Luchangco Virendra J. Marathe Nir Shavit @ MIT 2 Cores Chip (node)

More information

Chapter 9 Multiprocessors

Chapter 9 Multiprocessors ECE200 Computer Organization Chapter 9 Multiprocessors David H. lbonesi and the University of Rochester Henk Corporaal, TU Eindhoven, Netherlands Jari Nurmi, Tampere University of Technology, Finland University

More information

Locking: A necessary evil? Lecture 10: Avoiding Locks. Priority Inversion. Deadlock

Locking: A necessary evil? Lecture 10: Avoiding Locks. Priority Inversion. Deadlock Locking: necessary evil? Lecture 10: voiding Locks CSC 469H1F Fall 2006 ngela Demke Brown (with thanks to Paul McKenney) Locks are an easy to understand solution to critical section problem Protect shared

More information

A Non-Blocking Concurrent Queue Algorithm

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

More information

Lecture 21: Transactional Memory. Topics: Hardware TM basics, different implementations

Lecture 21: Transactional Memory. Topics: Hardware TM basics, different implementations Lecture 21: Transactional Memory Topics: Hardware TM basics, different implementations 1 Transactions New paradigm to simplify programming instead of lock-unlock, use transaction begin-end locks are blocking,

More information

Implementing Locks. Nima Honarmand (Based on slides by Prof. Andrea Arpaci-Dusseau)

Implementing Locks. Nima Honarmand (Based on slides by Prof. Andrea Arpaci-Dusseau) Implementing Locks Nima Honarmand (Based on slides by Prof. Andrea Arpaci-Dusseau) Lock Implementation Goals We evaluate lock implementations along following lines Correctness Mutual exclusion: only one

More information

Table ADT and Sorting. Algorithm topics continuing (or reviewing?) CS 24 curriculum

Table ADT and Sorting. Algorithm topics continuing (or reviewing?) CS 24 curriculum Table ADT and Sorting Algorithm topics continuing (or reviewing?) CS 24 curriculum A table ADT (a.k.a. Dictionary, Map) Table public interface: // Put information in the table, and a unique key to identify

More information

i219 Software Design Methodology 11. Software model checking Kazuhiro Ogata (JAIST) Outline of lecture

i219 Software Design Methodology 11. Software model checking Kazuhiro Ogata (JAIST) Outline of lecture i219 Software Design Methodology 11. Software model checking Kazuhiro Ogata (JAIST) Outline of lecture 2 Concurrency Model checking Java Pathfinder (JPF) Detecting race condition Bounded buffer problem

More information

Panu Silvasti Page 1

Panu Silvasti Page 1 Multicore support in databases Panu Silvasti Page 1 Outline Building blocks of a storage manager How do existing storage managers scale? Optimizing Shore database for multicore processors Page 2 Building

More information

Synchronization Basic Problem:

Synchronization Basic Problem: Synchronization Synchronization Basic Problem: If two concurrent processes are accessing a shared variable, and that variable is read, modified, and written by those processes, then the variable must be

More information

Programming with POSIX Threads

Programming with POSIX Threads Programming with POSIX Threads David R. Butenhof :vaddison-wesley Boston San Francisco New York Toronto Montreal London Munich Paris Madrid Capetown Sidney Tokyo Singapore Mexico City Contents List of

More information

A Simple Optimistic skip-list Algorithm

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

More information

6.852: Distributed Algorithms Fall, Class 20

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

More information

Administrivia. Review of last lecture. DPHPC Overview. Lamport s Bakery Algorithm (1974) Goals of this lecture

Administrivia. Review of last lecture. DPHPC Overview. Lamport s Bakery Algorithm (1974) Goals of this lecture Administrivia Design of Parallel and High-Performance Computing Fall 2013 Lecture: Locks and Lock-Free Next week progress presentations Make sure, Timo knows about your team (this step is important!) Send

More information

Uniprocessor Scheduling. Basic Concepts Scheduling Criteria Scheduling Algorithms. Three level scheduling

Uniprocessor Scheduling. Basic Concepts Scheduling Criteria Scheduling Algorithms. Three level scheduling Uniprocessor Scheduling Basic Concepts Scheduling Criteria Scheduling Algorithms Three level scheduling 2 1 Types of Scheduling 3 Long- and Medium-Term Schedulers Long-term scheduler Determines which programs

More information

SSC - Concurrency and Multi-threading Advanced topics about liveness

SSC - Concurrency and Multi-threading Advanced topics about liveness SSC - Concurrency and Multi-threading Advanced topics about liveness Shan He School for Computational Science University of Birmingham Module 06-19321: SSC Outline Outline of Topics Review what we learned

More information

Multiprocessor Cache Coherence. Chapter 5. Memory System is Coherent If... From ILP to TLP. Enforcing Cache Coherence. Multiprocessor Types

Multiprocessor Cache Coherence. Chapter 5. Memory System is Coherent If... From ILP to TLP. Enforcing Cache Coherence. Multiprocessor Types Chapter 5 Multiprocessor Cache Coherence Thread-Level Parallelism 1: read 2: read 3: write??? 1 4 From ILP to TLP Memory System is Coherent If... ILP became inefficient in terms of Power consumption Silicon

More information

A Skiplist-based Concurrent Priority Queue with Minimal Memory Contention

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

More information

Java Monitors. Parallel and Distributed Computing. Department of Computer Science and Engineering (DEI) Instituto Superior Técnico.

Java Monitors. Parallel and Distributed Computing. Department of Computer Science and Engineering (DEI) Instituto Superior Técnico. Java Monitors Parallel and Distributed Computing Department of Computer Science and Engineering (DEI) Instituto Superior Técnico October 19, 2010 Monteiro, Costa (DEI / IST) Parallel and Distributed Computing

More information

Lock-free Programming

Lock-free Programming Lock-free Programming Nathaniel Wesley Filardo April 10, 2006 Outline Motivation Lock-Free Linked List Insertion Lock-Free Linked List Deletion Some real algorithms? Motivation Review of atomic primitives

More information

1993 Paper 3 Question 6

1993 Paper 3 Question 6 993 Paper 3 Question 6 Describe the functionality you would expect to find in the file system directory service of a multi-user operating system. [0 marks] Describe two ways in which multiple names for

More information

CS 31: Intro to Systems Deadlock. Kevin Webb Swarthmore College April 21, 2015

CS 31: Intro to Systems Deadlock. Kevin Webb Swarthmore College April 21, 2015 CS 31: Intro to Systems Deadlock Kevin Webb Swarthmore College April 21, 2015 Reading Quiz Deadly Embrace The Structure of the THE-Multiprogramming System (Edsger Dijkstra, 1968) Also introduced semaphores

More information

Shared Mutable State SWEN-220

Shared Mutable State SWEN-220 Shared Mutable State SWEN-220 The Ultimate Culprit - Shared, Mutable State Most of your development has been in imperative languages. The fundamental operation is assignment to change state. Assignable

More information

Synchronization 1. Synchronization

Synchronization 1. Synchronization Synchronization 1 Synchronization key concepts critical sections, mutual exclusion, test-and-set, spinlocks, blocking and blocking locks, semaphores, condition variables, deadlocks reading Three Easy Pieces:

More information

Spring CS 170 Exercise Set 1 (Updated with Part III)

Spring CS 170 Exercise Set 1 (Updated with Part III) Spring 2015. CS 170 Exercise Set 1 (Updated with Part III) Due on May 5 Tuesday 12:30pm. Submit to the CS170 homework box or bring to the classroom. Additional problems will be added as we cover more topics

More information

CS510 Concurrent Systems. Jonathan Walpole

CS510 Concurrent Systems. Jonathan Walpole CS510 Concurrent Systems Jonathan Walpole Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms utline Background Non-Blocking Queue Algorithm Two Lock Concurrent Queue Algorithm

More information

Lock-free Cuckoo Hashing

Lock-free Cuckoo Hashing Lock-free Cuckoo Hashing Nhan Nguyen, Philippas Tsigas Chalmers University of Technology Gothenburg, Sweden Email: {nhann, tsigas}@chalmers.se Abstract This paper presents a lock-free cuckoo hashing algorithm;

More information

CS4961 Parallel Programming. Lecture 12: Advanced Synchronization (Pthreads) 10/4/11. Administrative. Mary Hall October 4, 2011

CS4961 Parallel Programming. Lecture 12: Advanced Synchronization (Pthreads) 10/4/11. Administrative. Mary Hall October 4, 2011 CS4961 Parallel Programming Lecture 12: Advanced Synchronization (Pthreads) Mary Hall October 4, 2011 Administrative Thursday s class Meet in WEB L130 to go over programming assignment Midterm on Thursday

More information

Chapter 5 Concurrency: Mutual Exclusion. and. Synchronization. Operating Systems: Internals. and. Design Principles

Chapter 5 Concurrency: Mutual Exclusion. and. Synchronization. Operating Systems: Internals. and. Design Principles Operating Systems: Internals and Design Principles Chapter 5 Concurrency: Mutual Exclusion and Synchronization Seventh Edition By William Stallings Designing correct routines for controlling concurrent

More information

( D ) 4. Which is not able to solve the race condition? (A) Test and Set Lock (B) Semaphore (C) Monitor (D) Shared memory

( D ) 4. Which is not able to solve the race condition? (A) Test and Set Lock (B) Semaphore (C) Monitor (D) Shared memory CS 540 - Operating Systems - Final Exam - Name: Date: Wenesday, May 12, 2004 Part 1: (78 points - 3 points for each problem) ( C ) 1. In UNIX a utility which reads commands from a terminal is called: (A)

More information

Programming Paradigms for Concurrency Lecture 3 Concurrent Objects

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

More information

Threads and Locks, Part 2. CSCI 5828: Foundations of Software Engineering Lecture 08 09/18/2014

Threads and Locks, Part 2. CSCI 5828: Foundations of Software Engineering Lecture 08 09/18/2014 Threads and Locks, Part 2 CSCI 5828: Foundations of Software Engineering Lecture 08 09/18/2014 1 Goals Cover the material presented in Chapter 2 of our concurrency textbook In particular, selected material

More information

Part II: Data Center Software Architecture: Topic 2: Key-value Data Management Systems. SkimpyStash: Key Value Store on Flash-based Storage

Part II: Data Center Software Architecture: Topic 2: Key-value Data Management Systems. SkimpyStash: Key Value Store on Flash-based Storage ECE 7650 Scalable and Secure Internet Services and Architecture ---- A Systems Perspective Part II: Data Center Software Architecture: Topic 2: Key-value Data Management Systems SkimpyStash: Key Value

More information

A Concurrent Bidirectional Linear Probing Algorithm

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

More information

Tree Search for Travel Salesperson Problem Pacheco Text Book Chapt 6 T. Yang, UCSB CS140, Spring 2014

Tree Search for Travel Salesperson Problem Pacheco Text Book Chapt 6 T. Yang, UCSB CS140, Spring 2014 Tree Search for Travel Salesperson Problem Pacheco Text Book Chapt 6 T. Yang, UCSB CS140, Spring 2014 Outline Tree search for travel salesman problem. Recursive code Nonrecusive code Parallelization with

More information

Concurrency: Locks. Announcements

Concurrency: Locks. Announcements CS 537 Introduction to Operating Systems UNIVERSITY of WISCONSIN-MADISON Computer Sciences Department Concurrency: Locks Andrea C. Arpaci-Dusseau Remzi H. Arpaci-Dusseau Questions answered in this lecture:

More information

Concurrency Race Conditions and Deadlocks

Concurrency Race Conditions and Deadlocks Concurrency Race Conditions and Deadlocks Kartik Gopalan Chapters 2 (2.3) and 6 Tanenbaum s Modern OS Sequential Loosely, doing many things, but one after another E.g. Finish one assignment, then another

More information

Chapter 11: Indexing and Hashing

Chapter 11: Indexing and Hashing Chapter 11: Indexing and Hashing Basic Concepts Ordered Indices B + -Tree Index Files B-Tree Index Files Static Hashing Dynamic Hashing Comparison of Ordered Indexing and Hashing Index Definition in SQL

More information

MULTITHREADING AND SYNCHRONIZATION. CS124 Operating Systems Fall , Lecture 10

MULTITHREADING AND SYNCHRONIZATION. CS124 Operating Systems Fall , Lecture 10 MULTITHREADING AND SYNCHRONIZATION CS124 Operating Systems Fall 2017-2018, Lecture 10 2 Critical Sections Race conditions can be avoided by preventing multiple control paths from accessing shared state

More information

Semaphore. Originally called P() and V() wait (S) { while S <= 0 ; // no-op S--; } signal (S) { S++; }

Semaphore. Originally called P() and V() wait (S) { while S <= 0 ; // no-op S--; } signal (S) { S++; } Semaphore Semaphore S integer variable Two standard operations modify S: wait() and signal() Originally called P() and V() Can only be accessed via two indivisible (atomic) operations wait (S) { while

More information

UNIVERSITY OF MASSACHUSETTS LOWELL Department of Electrical and Computer Engineering. Program 10 EECE.3220 Data Structures Fall 2017.

UNIVERSITY OF MASSACHUSETTS LOWELL Department of Electrical and Computer Engineering. Program 10 EECE.3220 Data Structures Fall 2017. UNIVERSITY OF MASSACHUSETTS LOWELL Department of Electrical and Computer Engineering Program 10 EECE.3220 Data Structures Fall 2017 Hash Tables Program 10 is a repeat of Program 9, but in Program 10 the

More information

Midterm on next week Tuesday May 4. CS 361 Concurrent programming Drexel University Fall 2004 Lecture 9

Midterm on next week Tuesday May 4. CS 361 Concurrent programming Drexel University Fall 2004 Lecture 9 CS 361 Concurrent programming Drexel University Fall 2004 Lecture 9 Bruce Char and Vera Zaychik. All rights reserved by the author. Permission is given to students enrolled in CS361 Fall 2004 to reproduce

More information

Chapter 12: Indexing and Hashing

Chapter 12: Indexing and Hashing Chapter 12: Indexing and Hashing Basic Concepts Ordered Indices B+-Tree Index Files B-Tree Index Files Static Hashing Dynamic Hashing Comparison of Ordered Indexing and Hashing Index Definition in SQL

More information

CS 470 Spring Mike Lam, Professor. Advanced OpenMP

CS 470 Spring Mike Lam, Professor. Advanced OpenMP CS 470 Spring 2017 Mike Lam, Professor Advanced OpenMP Atomics OpenMP provides access to highly-efficient hardware synchronization mechanisms Use the atomic pragma to annotate a single statement Statement

More information

atomicadd(int* address, int val); float atomicadd(float* address, float val); atomicsub(int* address, int val); atomicexch(int* address, int val);

atomicadd(int* address, int val); float atomicadd(float* address, float val); atomicsub(int* address, int val); atomicexch(int* address, int val); int atomicadd(int* address, int val); float atomicadd(float* address, float val); int int atomicsub(int* address, int val); atomicexch(int* address, int val); float atomicexch(float* address, float val);

More information

High Performance Computing Lecture 21. Matthew Jacob Indian Institute of Science

High Performance Computing Lecture 21. Matthew Jacob Indian Institute of Science High Performance Computing Lecture 21 Matthew Jacob Indian Institute of Science Semaphore Examples Semaphores can do more than mutex locks Example: Consider our concurrent program where process P1 reads

More information

Lecture 5 Threads and Pthreads II

Lecture 5 Threads and Pthreads II CSCI-GA.3033-017 Special Topics: Multicore Programming Lecture 5 Threads and Pthreads II Christopher Mitchell, Ph.D. cmitchell@cs.nyu.edu http://z80.me Context We re exploring the layers of an application

More information

Multiprocessors II: CC-NUMA DSM. CC-NUMA for Large Systems

Multiprocessors II: CC-NUMA DSM. CC-NUMA for Large Systems Multiprocessors II: CC-NUMA DSM DSM cache coherence the hardware stuff Today s topics: what happens when we lose snooping new issues: global vs. local cache line state enter the directory issues of increasing

More information

Distributed K-Ary System

Distributed K-Ary System A seminar presentation Arne Vater and Prof. Schindelhauer Professorship for Computer Networks and Telematik Department of Computer Science University of Freiburg 2007-03-01 Outline 1 2 3 4 5 Outline 1

More information

Concurrent Programming

Concurrent Programming Concurrent Programming CS 485G-006: Systems Programming Lectures 32 33: 18 20 Apr 2016 1 Concurrent Programming is Hard! The human mind tends to be sequential The notion of time is often misleading Thinking

More information

Stanford University Computer Science Department CS 140 Midterm Exam Dawson Engler Winter 1999

Stanford University Computer Science Department CS 140 Midterm Exam Dawson Engler Winter 1999 Stanford University Computer Science Department CS 140 Midterm Exam Dawson Engler Winter 1999 Name: Please initial the bottom left corner of each page. This is an open-book exam. You have 50 minutes to

More information

CS 111. Operating Systems Peter Reiher

CS 111. Operating Systems Peter Reiher Operating System Principles: Semaphores and Locks for Synchronization Operating Systems Peter Reiher Page 1 Outline Locks Semaphores Mutexes and object locking Getting good performance with locking Page

More information

Multiprocessor scheduling

Multiprocessor scheduling Chapter 10 Multiprocessor scheduling When a computer system contains multiple processors, a few new issues arise. Multiprocessor systems can be categorized into the following: Loosely coupled or distributed.

More information

20-EECE-4029 Operating Systems Spring, 2015 John Franco

20-EECE-4029 Operating Systems Spring, 2015 John Franco 20-EECE-4029 Operating Systems Spring, 2015 John Franco First Exam name: Question 1: Semaphores The code below produces a line consisting of 10 each of the letters A, B, and C. What other relationship

More information

Transactional Memory. Lecture 18: Parallel Computer Architecture and Programming CMU /15-618, Spring 2017

Transactional Memory. Lecture 18: Parallel Computer Architecture and Programming CMU /15-618, Spring 2017 Lecture 18: Transactional Memory Parallel Computer Architecture and Programming CMU 15-418/15-618, Spring 2017 Credit: many slides in today s talk are borrowed from Professor Christos Kozyrakis (Stanford

More information

Operating Systems Design Fall 2010 Exam 1 Review. Paul Krzyzanowski

Operating Systems Design Fall 2010 Exam 1 Review. Paul Krzyzanowski Operating Systems Design Fall 2010 Exam 1 Review Paul Krzyzanowski pxk@cs.rutgers.edu 1 Question 1 To a programmer, a system call looks just like a function call. Explain the difference in the underlying

More information

Comp 11 - Summer Session Hashmap

Comp 11 - Summer Session Hashmap Lab 14 Comp 11 - Summer Session Hashmap 14.1 Description In this lab we are going to implement part of a hashmap. Our hashmap is limited to storing pairs with a key of string and a value of string for

More information

Java s Implementation of Concurrency, and how to use it in our applications.

Java s Implementation of Concurrency, and how to use it in our applications. Java s Implementation of Concurrency, and how to use it in our applications. 1 An application running on a single CPU often appears to perform many tasks at the same time. For example, a streaming audio/video

More information

Multithreaded Programming Part II. CSE 219 Stony Brook University, Department of Computer Science

Multithreaded Programming Part II. CSE 219 Stony Brook University, Department of Computer Science Multithreaded Programming Part II CSE 219 Stony Brook University, Thread Scheduling In a Java application, main is a thread on its own Once multiple threads are made Runnable the thread scheduler of the

More information

G52CON: Concepts of Concurrency

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:

More information

mywbut.com Concurrency Control

mywbut.com Concurrency Control C H A P T E R 1 6 Concurrency Control This chapter describes how to control concurrent execution in a database, in order to ensure the isolation properties of transactions. A variety of protocols are described

More information

Flat Parallelization. V. Aksenov, ITMO University P. Kuznetsov, ParisTech. July 4, / 53

Flat Parallelization. V. Aksenov, ITMO University P. Kuznetsov, ParisTech. July 4, / 53 Flat Parallelization V. Aksenov, ITMO University P. Kuznetsov, ParisTech July 4, 2017 1 / 53 Outline Flat-combining PRAM and Flat parallelization PRAM binary heap with Flat parallelization ExtractMin Insert

More information

Microkernel/OS and Real-Time Scheduling

Microkernel/OS and Real-Time Scheduling Chapter 12 Microkernel/OS and Real-Time Scheduling Hongwei Zhang http://www.cs.wayne.edu/~hzhang/ Ack.: this lecture is prepared in part based on slides of Lee, Sangiovanni-Vincentelli, Seshia. Outline

More information