CS 33. Multithreaded Programming III. CS33 Intro to Computer Systems XXXIV 1 Copyright 2017 Thomas W. Doeppner. All rights reserved.
|
|
|
- Arthur Goodwin
- 6 years ago
- Views:
Transcription
1 CS 33 Multithreaded Programming III CS33 Intro to Computer Systems XXXIV 1 Copyright 2017 Thomas W. Doeppner. All rights reserved.
2 Start/Stop Start/Stop interface void wait_for_start(state_t *s); void start(state_t *s); void stop(state_t *s); CS33 Intro to Computer Systems XXXIV 2 Copyright 2017 Thomas W. Doeppner. All rights reserved.
3 Start/Stop Start/Stop interface void wait_for_start(state_t *s){ if (s->state == stopped) sleep(); void start(state_t *s) { state = started; wakeup_all(); void stop(state_t *s) { state = stopped; CS33 Intro to Computer Systems XXXIV 3 Copyright 2017 Thomas W. Doeppner. All rights reserved.
4 Start/Stop Start/Stop interface void wait_for_start(state_t *s){ pthread_mutex_lock(&s->mutex); if (s->state == stopped) { pthread_mutex_unlock(&s->mutex); sleep(); else pthread_mutex_unlock(&s->mutex); void start(state_t *s) { pthread_mutex_lock(&s->mutex); state = started; wakeup_all(); pthread_mutex_unlock(&s->mutex); CS33 Intro to Computer Systems XXXIV 4 Copyright 2017 Thomas W. Doeppner. All rights reserved.
5 Start/Stop Start/Stop interface void wait_for_start(state_t *s){ pthread_mutex_lock(&s->mutex); if (s->state == stopped) { sleep(); pthread_mutex_unlock(&s->mutex); void start(state_t *s) { pthread_mutex_lock(&s->mutex); state = started; wakeup_all(); pthread_mutex_unlock(&s->mutex); CS33 Intro to Computer Systems XXXIV 5 Copyright 2017 Thomas W. Doeppner. All rights reserved.
6 Start/Stop Start/Stop interface void wait_for_start(state_t *s){ pthread_mutex_lock(&s->mutex); while(s->state == stopped) pthread_cond_wait(&s->queue, &s->mutex); pthread_mutex_unlock(&s->mutex); void start(state_t *s) { pthread_mutex_lock(&s->mutex); s->state = started; pthread_cond_broadcast(&s->queue); pthread_mutex_unlock(&s->mutex); CS33 Intro to Computer Systems XXXIV 6 Copyright 2017 Thomas W. Doeppner. All rights reserved.
7 Condition Variables when (guard) [ statement 1; statement n; ] pthread_mutex_lock(&mutex); while(!guard) pthread_cond_wait( &cond_var, &mutex); statement 1; statement n; pthread_mutex_unlock(&mutex); // code modifying the guard: pthread_mutex_lock(&mutex); // code modifying the guard: pthread_cond_broadcast( &cond_var); pthread_mutex_unlock(&mutex); CS33 Intro to Computer Systems XXXIV 7 Copyright 2017 Thomas W. Doeppner. All rights reserved.
8 Set Up int pthread_cond_init(pthread_cond_t *cvp, pthread_condattr_t *attrp) int pthread_cond_destroy(pthread_cond_t *cvp) int pthread_condattr_init(pthread_condattr_t *attrp) int pthread_condattr_destroy(pthread_condattr_t *attrp) CS33 Intro to Computer Systems XXXIV 8 Copyright 2017 Thomas W. Doeppner. All rights reserved.
9 PC with Condition Variables (1) typedef struct buffer { pthread_mutex_t m; pthread_cond_t more_space; pthread_cond_t more_items; int next_in; int next_out; int empty; char buf[bsize]; buffer_t; CS33 Intro to Computer Systems XXXIV 9 Copyright 2017 Thomas W. Doeppner. All rights reserved.
10 PC with Condition Variables (2) void produce(buffer_t *b, char item) { pthread_mutex_lock(&b->m); while (!(b->empty > 0)) pthread_cond_wait( &b->more_space, &b->m); b->buf[b->nextin] = item; if (++(b->nextin) == BSIZE) b->nextin = 0; b->empty--; pthread_cond_signal( &b->more_items); pthread_mutex_unlock(&b->m); char consume(buffer_t *b) { char item; pthread_mutex_lock(&b->m); while (!(b->empty < BSIZE)) pthread_cond_wait( &b->more_items, &b->m); item = b->buf[b->nextout]; if (++(b->nextout) == BSIZE) b->nextout = 0; b->empty++; pthread_cond_signal( &b->more_space); pthread_mutex_unlock(&b->m); return item; CS33 Intro to Computer Systems XXXIV 10 Copyright 2017 Thomas W. Doeppner. All rights reserved.
11 Quiz 1 void produce(buffer_t *b, char item) { pthread_mutex_lock(&b->m); if (!(b->empty > 0)) pthread_cond_wait( &b->more_space, &b->m); b->buf[b->nextin] = item; if (++(b->nextin) == BSIZE) b->nextin = 0; b->empty--; pthread_cond_signal( &b->more_items); pthread_mutex_unlock(&b->m); char consume(buffer_t *b) { char item; pthread_mutex_lock(&b->m); if (!(b->empty < BSIZE)) pthread_cond_wait( &b->more_items, &b->m); item = b->buf[b->nextout]; if (++(b->nextout) == BSIZE) b->nextout = 0; b->empty++; pthread_cond_signal( &b->more_space); pthread_mutex_unlock(&b->m); return item; Assume pthread_cond_wait returns only in response to pthread_cond_signal. Does the above work? a) yes b) no CS33 Intro to Computer Systems XXXIV 11 Copyright 2017 Thomas W. Doeppner. All rights reserved.
12 Readers-Writers Problem CS33 Intro to Computer Systems XXXIV 12 Copyright 2017 Thomas W. Doeppner. All rights reserved.
13 Pseudocode reader( ) { when (writers == 0) [ readers++; ] /* read */ [readers--;] writer( ) { when ((writers == 0) && (readers == 0)) [ writers++; ] /* write */ [writers--;] CS33 Intro to Computer Systems XXXIV 13 Copyright 2017 Thomas W. Doeppner. All rights reserved.
14 Pseudocode with Assertions reader( ) { when (writers == 0) [ readers++; ] assert((writers == 0) && (readers > 0)); /* read */ [readers--;] writer( ) { when ((writers == 0) && (readers == 0)) [ writers++; ] assert((readers == 0) && (writers == 1)); /* write */ [writers--;] CS33 Intro to Computer Systems XXXIV 14 Copyright 2017 Thomas W. Doeppner. All rights reserved.
15 Solution with POSIX Threads reader( ) { pthread_mutex_lock(&m); while (!(writers == 0)) pthread_cond_wait( &readersq, &m); readers++; pthread_mutex_unlock(&m); /* read */ pthread_mutex_lock(&m); if (--readers == 0) pthread_cond_signal( &writersq); pthread_mutex_unlock(&m); writer( ) { pthread_mutex_lock(&m); while(!((readers == 0) && (writers == 0))) pthread_cond_wait( &writersq, &m); writers++; pthread_mutex_unlock(&m); /* write */ pthread_mutex_lock(&m); writers--; pthread_cond_signal( &writersq); pthread_cond_broadcast( &readersq); pthread_mutex_unlock(&m); CS33 Intro to Computer Systems XXXIV 15 Copyright 2017 Thomas W. Doeppner. All rights reserved.
16 New Pseudocode reader( ) { when (writers == 0) [ readers++; ] /* read */ writer( ) { [writers++;] when ((readers == 0) && (active_writers == 0)) [ active_writers++; ] [readers--;] /* write */ [writers--; active_writers--;] CS33 Intro to Computer Systems XXXIV 16 Copyright 2017 Thomas W. Doeppner. All rights reserved.
17 Improved Reader reader( ) { pthread_mutex_lock(&m); while (!(writers == 0)) { pthread_cond_wait( &readersq, &m); readers++; pthread_mutex_unlock(&m); pthread_mutex_lock(&m); if (--readers == 0) pthread_cond_signal( &writersq); pthread_mutex_unlock(&m); /* read */ CS33 Intro to Computer Systems XXXIV 17 Copyright 2017 Thomas W. Doeppner. All rights reserved.
18 Improved Writer writer( ) { pthread_mutex_lock(&m); writers++; while (!((readers == 0) && (active_writers == 0))) { pthread_cond_wait( &writersq, &m); active_writers++; pthread_mutex_unlock(&m); /* write */ pthread_mutex_lock(&m); writers--; active_writers--; if (writers) pthread_cond_signal( &writersq); else pthread_cond_broadcast( &readersq); pthread_mutex_unlock(&m); CS33 Intro to Computer Systems XXXIV 18 Copyright 2017 Thomas W. Doeppner. All rights reserved.
19 New, From POSIX! int pthread_rwlock_init(pthread_rwlock_t *lock, pthread_rwlockattr_t *att); int pthread_rwlock_destroy(pthread_rwlock_t *lock); int pthread_rwlock_rdlock(pthread_rwlock_t *lock); int pthread_rwlock_wrlock(pthread_rwlock_t *lock); int pthread_rwlock_tryrdlock(pthread_rwlock_t *lock); int pthread_rwlock_trywrlock(pthread_rwlock_t *lock); int pthread_timedrwlock_rdlock(pthread_rwlock_t *lock, struct timespec *ts); int pthread_timedrwlock_wrlock(pthread_rwlock_t *lock, struct timespec *ts); int pthread_rwlock_unlock(pthread_rwlock_t *lock); CS33 Intro to Computer Systems XXXIV 19 Copyright 2017 Thomas W. Doeppner. All rights reserved.
20 Binary Search Tree CS33 Intro to Computer Systems XXXIV 20 Copyright 2017 Thomas W. Doeppner. All rights reserved.
21 Binary Search Tree: Insertion CS33 Intro to Computer Systems XXXIV 21 Copyright 2017 Thomas W. Doeppner. All rights reserved.
22 Binary Search Tree: Deletion of Leaf CS33 Intro to Computer Systems XXXIV 22 Copyright 2017 Thomas W. Doeppner. All rights reserved.
23 Binary Search Tree: Deletion of Leaf CS33 Intro to Computer Systems XXXIV 23 Copyright 2017 Thomas W. Doeppner. All rights reserved.
24 Binary Search Tree: Deletion of Node with One Child CS33 Intro to Computer Systems XXXIV 24 Copyright 2017 Thomas W. Doeppner. All rights reserved.
25 Binary Search Tree: Deletion of Node with One Child CS33 Intro to Computer Systems XXXIV 25 Copyright 2017 Thomas W. Doeppner. All rights reserved.
26 Binary Search Tree: Deletion of Node with Two Children -1 X: Y: 7 CS33 Intro to Computer Systems XXXIV 26 Copyright 2017 Thomas W. Doeppner. All rights reserved.
27 Binary Search Tree: Deletion of Node with Two Children -1 Y: CS33 Intro to Computer Systems XXXIV 27 Copyright 2017 Thomas W. Doeppner. All rights reserved.
28 C Code: Search Node *search(int key, Node *parent, Node **parentp) { Node *next; Node *result; if (key < parent->key) { if ((next = parent->lchild) == 0) { result = 0; else { if (key == next->key) { result = next; else { result = search(key, next, parentpp); return result; else { if ((next = parent->rchild) == 0) { result = 0; else { if (key == next->key) { result = next; else { result = search(key, next, parentpp); return result; if (parentpp!= 0) *parentpp = parent; return result; CS33 Intro to Computer Systems XXXIV 28 Copyright 2017 Thomas W. Doeppner. All rights reserved.
29 C Code: Add int add(int key) { Node *parent, *target, *newnode; if ((target = search(key, &head, &parent))!= 0) { return 0; newnode = malloc(sizeof(node)); newnode->key = key; newnode->lchild = newnode->rchild = 0; if (name < parent->name) parent->lchild = newnode; else parent->rchild = newnode; return 1; CS33 Intro to Computer Systems XXXIV 29 Copyright 2017 Thomas W. Doeppner. All rights reserved.
30 Binary Search Tree with Coarse-Grained Synchronization CS33 Intro to Computer Systems XXXIV 30 Copyright 2017 Thomas W. Doeppner. All rights reserved.
31 C Code: Add with Coarse-Grained Synchronization int add(int key) { Node *parent, *target, *newnode; pthread_rwlock_wrlock(&tree_lock); if ((target = search(key, &head, &parent))!= 0) { pthread_rwlock_unlock(&tree_lock); return 0; newnode = malloc(sizeof(node)); newnode->key = key; newnode->lchild = newnode->rchild = 0; if (name < parent->name) parent->lchild = newnode; else parent->rchild = newnode; pthread_rwlock_unlock(&tree_lock); return 1; CS33 Intro to Computer Systems XXXIV 31 Copyright 2017 Thomas W. Doeppner. All rights reserved.
32 Binary Search Tree with Fine-Grained Synchronization I CS33 Intro to Computer Systems XXXIV 32 Copyright 2017 Thomas W. Doeppner. All rights reserved.
33 Binary Search Tree with Fine-Grained Synchronization II CS33 Intro to Computer Systems XXXIV 33 Copyright 2017 Thomas W. Doeppner. All rights reserved.
34 Binary Search Tree with Fine-Grained Synchronization III -1 4? 1 5 CS33 Intro to Computer Systems XXXIV 34 Copyright 2017 Thomas W. Doeppner. All rights reserved.
35 Doing It Right CS33 Intro to Computer Systems XXXIV 35 Copyright 2017 Thomas W. Doeppner. All rights reserved.
36 C Code: Fine-Grained Search I enum locktype {l_read, l_write; #define lock(lt, lk) ((lt) == l_read)? pthread_rwlock_rdlock(lk): pthread_rwlock_wrlock(lk) Node *search(int key, Node *parent, Node **parentp, enum locktype lt) { // parent is locked on entry Node *next; Node *result; if (key < parent->key) { if ((next = parent->lchild) == 0) { result = 0; else { lock(lt, &next->lock); if (key == next->key) { result = next; else { pthread_rwlock_unlock( &parent->lock); result = search(key, next, parentpp, lt); return result; CS33 Intro to Computer Systems XXXIV 36 Copyright 2017 Thomas W. Doeppner. All rights reserved.
37 C Code: Fine-Grained Search II else { if ((next = parent->rchild) == 0) { result = 0; else { lock(lt, &next->lock); if (key == next->key) { result = next; else { pthread_rwlock_unlock( &parent->lock); result = search(key, next, parentpp, lt); return result; if (parentpp!= 0) { // parent remains locked *parentpp = parent; else pthread_rwlock_unlock( &parent->lock); return result; CS33 Intro to Computer Systems XXXIV 37 Copyright 2017 Thomas W. Doeppner. All rights reserved.
38 C Code: Add with Fine-Grained Synchronization I int add(int key) { Node *parent, *target, *newnode; pthread_rwlock_wrlock(&head->lock); if ((target = search(key, &head, &parent, l_write))!= 0) { pthread_rwlock_unlock(&target->lock); pthread_rwlock_unlock(&parent->lock); return 0; CS33 Intro to Computer Systems XXXIV 38 Copyright 2017 Thomas W. Doeppner. All rights reserved.
39 C Code: Add with Fine-Grained Synchronization II newnode = malloc(sizeof(node)); newnode->key = key; newnode->lchild = newnode->rchild = 0; pthread_rwlock_init(&newnode->lock, 0); if (name < parent->name) parent->lchild = newnode; else parent->rchild = newnode; pthread_rwlock_unlock(&parent->lock); return 1; CS33 Intro to Computer Systems XXXIV 39 Copyright 2017 Thomas W. Doeppner. All rights reserved.
40 Barriers CS33 Intro to Computer Systems XXXIV 40 Copyright 2017 Thomas W. Doeppner. All rights reserved.
41 A Solution? pthread_mutex_lock(&m); if (++count == number) { pthread_cond_broadcast(&cond_var); else while (!(count == number)) { pthread_cond_wait(&cond_var, &m); pthread_mutex_unlock(&m); CS33 Intro to Computer Systems XXXIV 41 Copyright 2017 Thomas W. Doeppner. All rights reserved.
42 How About This? pthread_mutex_lock(&m); if (++count == number) { pthread_cond_broadcast(&cond_var); count = 0; else while (!(count == number)) { pthread_cond_wait(&cond_var, &m); pthread_mutex_unlock(&m); CS33 Intro to Computer Systems XXXIV 42 Copyright 2017 Thomas W. Doeppner. All rights reserved.
43 And This... Quiz 2 Does it work? pthread_mutex_lock(&m); if (++count == number) { pthread_cond_broadcast(&cond_var); count = 0; else { pthread_cond_wait(&cond_var, &m); pthread_mutex_unlock(&m); a) yes b) no CS33 Intro to Computer Systems XXXIV 43 Copyright 2017 Thomas W. Doeppner. All rights reserved.
44 Barrier in POSIX Threads pthread_mutex_lock(&m); if (++count < number) { int my_generation = generation; while(my_generation == generation) { pthread_cond_wait(&waitq, &m); else { count = 0; generation++; pthread_cond_broadcast(&waitq); pthread_mutex_unlock(&m); CS33 Intro to Computer Systems XXXIV 44 Copyright 2017 Thomas W. Doeppner. All rights reserved.
45 More From POSIX! int pthread_barrier_init(pthread_barrier_t *barrier, pthread_barrierattr_t *attr, unsigned int count); int pthread_barrier_destroy( pthread_barrier_t *barrier); int pthread_barrier_wait( pthread_barrier_t *barrier); CS33 Intro to Computer Systems XXXIV 45 Copyright 2017 Thomas W. Doeppner. All rights reserved.
46 Why cond_wait is Weird pthread_cond_wait(pthread_cond_t *c, pthread_mutex_t *m) { pthread_mutex_unlock(m); sem_wait(c->sem); pthread_mutex_lock(m); pthread_cond_signal(pthread_cond_t *c) { sem_post(c->sem); CS33 Intro to Computer Systems XXXIV 46 Copyright 2017 Thomas W. Doeppner. All rights reserved.
Introduction to parallel computing
Introduction to parallel computing Shared Memory Programming with Pthreads (3) Zhiao Shi (modifications by Will French) Advanced Computing Center for Education & Research Vanderbilt University Last time
Synchronization and Semaphores. Copyright : University of Illinois CS 241 Staff 1
Synchronization and Semaphores Copyright : University of Illinois CS 241 Staff 1 Synchronization Primatives Counting Semaphores Permit a limited number of threads to execute a section of the code Binary
Lab 12 - Concurrency 2
CSCI0330 Intro Computer Systems Doeppner Lab 12 - Concurrency 2 Due: December 11, 2018 at 6:00 PM Note: The late deadline for this lab is Friday, December 14th, at 11:59pm. If you hand in after this, you
CSCE 313: Introduction to Computer Systems
CSCE 313 Introduction to Computer Systems Instructor: Dr. Guofei Gu http://courses.cse.tamu.edu/guofei/csce313 POSIX Thread Synchronization Mutex Locks Condition Variables Read-Write Locks Semaphores Reading:
Synchronization and Semaphores. Copyright : University of Illinois CS 241 Staff 1
Synchronization and Semaphores Copyright : University of Illinois CS 241 Staff 1 Synchronization Primatives Counting Semaphores Permit a limited number of threads to execute a section of the code Binary
POSIX Threads. HUJI Spring 2011
POSIX Threads HUJI Spring 2011 Why Threads The primary motivation for using threads is to realize potential program performance gains and structuring. Overlapping CPU work with I/O. Priority/real-time
CS 33. Multithreaded Programming IV. CS33 Intro to Computer Systems XXXV 1 Copyright 2017 Thomas W. Doeppner. All rights reserved.
CS 33 Multithreaded Programming IV CS33 Intro to Computer Systems XXXV 1 Copyright 2017 Thomas W. Doeppner. All rights reserved. Deviations Signals vs. Cancellation tamed lightning CS33 Intro to Computer
COSC 6374 Parallel Computation. Shared memory programming with POSIX Threads. Edgar Gabriel. Fall References
COSC 6374 Parallel Computation Shared memory programming with POSIX Threads Fall 2012 References Some of the slides in this lecture is based on the following references: http://www.cobweb.ecn.purdue.edu/~eigenman/ece563/h
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 ++;
Concurrency, Parallel and Distributed
Threads (Chapter 11) Process -- Program, Memory (text, data, bss, heap, stack), execution stack - directly linked to execution function call frame, on the stack CPU -- execution "engine" Early computers:
Real Time Operating Systems and Middleware
Real Time Operating Systems and Middleware POSIX Threads Synchronization Luca Abeni abeni@dit.unitn.it Real Time Operating Systems and Middleware p. 1 Threads Synchronisation All the threads running in
CS 470 Spring Mike Lam, Professor. Semaphores and Conditions
CS 470 Spring 2018 Mike Lam, Professor Semaphores and Conditions Synchronization mechanisms Busy-waiting (wasteful!) Atomic instructions (e.g., LOCK prefix in x86) Pthreads Mutex: simple mutual exclusion
Multithreading Programming II
Multithreading Programming II Content Review Multithreading programming Race conditions Semaphores Thread safety Deadlock Review: Resource Sharing Access to shared resources need to be controlled to ensure
Condition Variables. Dongkun Shin, SKKU
Condition Variables 1 Why Condition? cases where a thread wishes to check whether a condition is true before continuing its execution 1 void *child(void *arg) { 2 printf("child\n"); 3 // XXX how to indicate
Paralleland Distributed Programming. Concurrency
Paralleland Distributed Programming Concurrency Concurrency problems race condition synchronization hardware (eg matrix PCs) software (barrier, critical section, atomic operations) mutual exclusion critical
CS 153 Lab6. Kishore Kumar Pusukuri
Outline Mutex vs Condition Variables Unlocking and locking mutex leads spinning or polling, wastes CPU time. We could sleep for some amount of time, but we do not know how long to sleep. A mutex is for
CS 167 Midterm Exam. Two Hours; Closed Book; Please Use a Black Pen March 23, 2017
CS 167 Midterm Exam Two Hours; Closed Book; Please Use a Black Pen March 23, 2017 Do all questions. 1. A certain operating system has a synchronization construct known as events. Assume there are two operations
More Shared Memory Programming
More Shared Memory Programming Shared data structures We want to make data structures that can be shared by threads. For example, our program to copy a file from one disk to another used a shared FIFO
Locks and semaphores. Johan Montelius KTH
Locks and semaphores Johan Montelius KTH 2018 1 / 40 recap, what s the problem : # include < pthread.h> volatile int count = 0; void * hello ( void * arg ) { for ( int i = 0; i < 10; i ++) { count ++;
Condition Variables. Dongkun Shin, SKKU
Condition Variables 1 Why Condition? cases where a thread wishes to check whether a condition is true before continuing its execution 1 void *child(void *arg) { 2 printf("child\n"); 3 // XXX how to indicate
Warm-up question (CS 261 review) What is the primary difference between processes and threads from a developer s perspective?
Warm-up question (CS 261 review) What is the primary difference between processes and threads from a developer s perspective? CS 470 Spring 2019 POSIX Mike Lam, Professor Multithreading & Pthreads MIMD
Synchronization. Semaphores implementation
Synchronization Semaphores implementation Possible implementations There are seeral possible implementations (standard and non standard)of a semaphore Semaphores through pipe POSIX semaphores Linux semaphores
recap, what s the problem Locks and semaphores Total Store Order Peterson s algorithm Johan Montelius 0 0 a = 1 b = 1 read b read a
recap, what s the problem Locks and semaphores Johan Montelius KTH 2017 # include < pthread.h> volatile int count = 0; void * hello ( void * arg ) { for ( int i = 0; i < 10; i ++) { count ++; int main
Operating Systems CMPSCI 377 Spring Mark Corner University of Massachusetts Amherst
Operating Systems CMPSCI 377 Spring 2017 Mark Corner University of Massachusetts Amherst What is a Monitor? Ties data and the synchronization operations together Monitors guarantee mutual exclusion, i.e.,
Programming Shared Address Space Platforms (cont.) Alexandre David B2-206
Programming Shared Address Space Platforms (cont.) Alexandre David B2-206 1 Today Finish thread synchronization. Effort for pthreads = synchronization. Effort for MPI = communication. OpenMP. Extra material
ANSI/IEEE POSIX Standard Thread management
Pthread Prof. Jinkyu Jeong( jinkyu@skku.edu) TA Jinhong Kim( jinhong.kim@csl.skku.edu) TA Seokha Shin(seokha.shin@csl.skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu The
Multithread Programming. Alexandre David
Multithread Programming Alexandre David 1.2.05 adavid@cs.aau.dk Comparison Directive based: OpenMP. Explicit parallel programming: pthreads shared memory focus on synchronization, MPI message passing focus
Operating systems and concurrency (B08)
Operating systems and concurrency (B08) David Kendall Northumbria University David Kendall (Northumbria University) Operating systems and concurrency (B08) 1 / 20 Introduction Semaphores provide an unstructured
THREADS. Jo, Heeseung
THREADS Jo, Heeseung TODAY'S TOPICS Why threads? Threading issues 2 PROCESSES Heavy-weight A process includes many things: - An address space (all the code and data pages) - OS resources (e.g., open files)
CSci 4061 Introduction to Operating Systems. Synchronization Basics: Locks
CSci 4061 Introduction to Operating Systems Synchronization Basics: Locks Synchronization Outline Basics Locks Condition Variables Semaphores Basics Race condition: threads + shared data Outcome (data
Faculté Polytechnique
Faculté Polytechnique Real-Time Systems - Practical Work 5 POSIX Threads Dr Frémal Sébastien Sebastien.FREMAL@umons.ac.be Ir Michel Bagein Michel.BAGEIN@umons.ac.be Prof. Pierre Manneback Pierre.MANNEBACK@umons.ac.be
Threads. Jo, Heeseung
Threads Jo, Heeseung Multi-threaded program 빠른실행 프로세스를새로생성에드는비용을절약 데이터공유 파일, Heap, Static, Code 의많은부분을공유 CPU 를보다효율적으로활용 코어가여러개일경우코어에 thread 를할당하는방식 2 Multi-threaded program Pros. Cons. 대량의데이터처리에적합 - CPU
Condition Variables. Jinkyu Jeong Computer Systems Laboratory Sungkyunkwan University
Condition Variables Jinkyu Jeong (jinkyu@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu EEE3052: Introduction to Operating Systems, Fall 2017, Jinkyu Jeong (jinkyu@skku.edu)
Threads need to synchronize their activities to effectively interact. This includes:
KING FAHD UNIVERSITY OF PETROLEUM AND MINERALS Information and Computer Science Department ICS 431 Operating Systems Lab # 8 Threads Synchronization ( Mutex & Condition Variables ) Objective: When multiple
Programming RT systems with pthreads
Programming RT systems with pthreads Giuseppe Lipari http://feanor.sssup.it/~lipari Scuola Superiore Sant Anna Pisa December 1, 2011 Outline 1 Timing utilities 2 Periodic threads 3 Scheduler selection
CS 220: Introduction to Parallel Computing. Condition Variables. Lecture 24
CS 220: Introduction to Parallel Computing Condition Variables Lecture 24 Remember: Creating a Thread int pthread_create( pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *),
Lecture 6 Coordinating Resources
CSCI-GA.0480-010 Special Topics: Multicore Programming Lecture 6 Coordinating Resources Christopher Mitchell, Ph.D. cmitchell@cs.nyu.edu http://z80.me Homework 1 Review Types of Parallelism Instruction-Level
Process Synchronization
Process Synchronization Part III, Modified by M.Rebaudengo - 2013 Silberschatz, Galvin and Gagne 2009 POSIX Synchronization POSIX.1b standard was adopted in 1993 Pthreads API is OS-independent It provides:
Synchronization II. Today. ! Condition Variables! Semaphores! Monitors! and some classical problems Next time. ! Deadlocks
Synchronization II Today Condition Variables Semaphores Monitors and some classical problems Next time Deadlocks Condition variables Many times a thread wants to check whether a condition is true before
What is uop Cracking?
Nehalem - Part 1 What is uop Cracking? uops are components of larger macro ops. uop cracking is taking CISC like instructions to RISC like instructions it would be good to crack CISC ops in parallel
Solving the Producer Consumer Problem with PThreads
Solving the Producer Consumer Problem with PThreads Michael Jantz Dr. Prasad Kulkarni Dr. Douglas Niehaus EECS 678 Pthreads: Producer-Consumer 1 Introduction This lab is an extension of last week's lab.
Process Synchronization(2)
CSE 3221.3 Operating System Fundamentals No.6 Process Synchronization(2) Prof. Hui Jiang Dept of Computer Science and Engineering York University Semaphores Problems with the software solutions. Not easy
Data Races and Deadlocks! (or The Dangers of Threading) CS449 Fall 2017
Data Races and Deadlocks! (or The Dangers of Threading) CS449 Fall 2017 Data Race Shared Data: 465 1 8 5 6 209? tail A[] thread switch Enqueue(): A[tail] = 20; tail++; A[tail] = 9; tail++; Thread 0 Thread
Threads. Jo, Heeseung
Threads Jo, Heeseung Multi-threaded program 빠른실행 프로세스를새로생성에드는비용을절약 데이터공유 파일, Heap, Static, Code 의많은부분을공유 CPU 를보다효율적으로활용 코어가여러개일경우코어에 thread 를할당하는방식 2 Multi-threaded program Pros. Cons. 대량의데이터처리에적합 - CPU
Threads. Jinkyu Jeong Computer Systems Laboratory Sungkyunkwan University
Threads Jinkyu Jeong (jinkyu@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu EEE3052: Introduction to Operating Systems, Fall 2017, Jinkyu Jeong (jinkyu@skku.edu) Concurrency
Synchronization Primitives
Synchronization Primitives Locks Synchronization Mechanisms Very primitive constructs with minimal semantics Semaphores A generalization of locks Easy to understand, hard to program with Condition Variables
Process Synchronization(2)
EECS 3221.3 Operating System Fundamentals No.6 Process Synchronization(2) Prof. Hui Jiang Dept of Electrical Engineering and Computer Science, York University Semaphores Problems with the software solutions.
Synchronization II. q Condition Variables q Semaphores and monitors q Some classical problems q Next time: Deadlocks
Synchronization II q Condition Variables q Semaphores and monitors q Some classical problems q Next time: Deadlocks Condition variables Locks are not enough to build concurrent programs Many times a thread
Synchronization Mechanisms
Synchronization Mechanisms CSCI 4061 Introduction to Operating Systems Instructor: Abhishek Chandra Mutex Locks Enforce protection and mutual exclusion Condition variables Allow atomic checking of conditions
Synchroniza+on II COMS W4118
Synchroniza+on II COMS W4118 References: Opera+ng Systems Concepts (9e), Linux Kernel Development, previous W4118s Copyright no2ce: care has been taken to use only those web images deemed by the instructor
CS 105, Spring 2007 Ring Buffer
CS 105, Spring 2007 Ring Buffer April 11, 2007 1 Introduction A ring buffer, also called a circular buffer, is a common method of sharing information between a producer and a consumer. In class, we have
Lecture 6. Process Synchronization
Lecture 6 Process Synchronization 1 Lecture Contents 1. Principles of Concurrency 2. Hardware Support 3. Semaphores 4. Monitors 5. Readers/Writers Problem 2 1. Principles of Concurrency OS design issue
Chapter 20: Binary Trees
Chapter 20: Binary Trees 20.1 Definition and Application of Binary Trees Definition and Application of Binary Trees Binary tree: a nonlinear linked list in which each node may point to 0, 1, or two other
Programming RT systems with pthreads
Programming RT systems with pthreads Giuseppe Lipari http://www.lifl.fr/~lipari CRIStAL - University de Lille 1 October 4, 2015 G. Lipari (CRIStAL) Programming RT systems with pthreads October 4, 2015
Motivation and definitions Processes Threads Synchronization constructs Speedup issues
Motivation and definitions Processes Threads Synchronization constructs Speedup issues Overhead Caches Amdahl s Law CS550: Advanced Operating Systems 2 If task can be completely decoupled into independent
CS 33. Multithreaded Programming V. CS33 Intro to Computer Systems XXXVI 1 Copyright 2018 Thomas W. Doeppner. All rights reserved.
CS 33 Multithreaded Programming V CS33 Intro to Computer Systems XXXVI 1 Copyright 2018 Thomas W. Doeppner. All rights reserved. Alternatives to Mutexes: Atomic Instructions Read-modify-write performed
Access to the same variable
Synchronization Access to the same variable Multiprogramming in OS allows different processes or threads to access common data Read write The order by which tasks are schedule can produce multiple results
Operating System Labs. Yuanbin Wu
Operating System Labs Yuanbin Wu CS@ECNU Operating System Labs Project 4 Due: 10 Dec. Oral tests of Project 3 Date: Nov. 27 How 5min presentation 2min Q&A Operating System Labs Oral tests of Lab 3 Who
CIS Operating Systems Application of Semaphores. Professor Qiang Zeng Spring 2018
CIS 3207 - Operating Systems Application of Semaphores Professor Qiang Zeng Spring 2018 Big picture of synchronization primitives Busy-waiting Software solutions (Dekker, Bakery, etc.) Hardware-assisted
CS 25200: Systems Programming. Lecture 26: Classic Synchronization Problems
CS 25200: Systems Programming Lecture 26: Classic Synchronization Problems Dr. Jef Turkstra 2018 Dr. Jeffrey A. Turkstra 1 Announcements Lab 5 posted this evening Web server Password protection SSL cgi-bin
Pthreads. Jin-Soo Kim Computer Systems Laboratory Sungkyunkwan University
Pthreads Jin-Soo Kim (jinsookim@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu The Pthreads API ANSI/IEEE POSIX1003.1-1995 Standard Thread management Work directly on
Computer Systems Laboratory Sungkyunkwan University
Threads Jin-Soo Kim (jinsookim@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu Today s Topics Why threads? Threading issues 2 Processes Heavy-weight A process includes
Process Synchronization(2)
EECS 3221.3 Operating System Fundamentals No.6 Process Synchronization(2) Prof. Hui Jiang Dept of Electrical Engineering and Computer Science, York University Semaphores Problems with the software solutions.
Thread Posix: Condition Variables Algoritmi, Strutture Dati e Calcolo Parallelo. Daniele Loiacono
Thread Posix: Condition Variables Algoritmi, Strutture Dati e Calcolo Parallelo References The material in this set of slide is taken from two tutorials by Blaise Barney from the Lawrence Livermore National
Introduc)on to pthreads. Shared memory Parallel Programming
Introduc)on to pthreads Shared memory Parallel Programming pthreads Hello world Compute pi pthread func)ons Prac)ce Problem (OpenMP to pthreads) Sum and array Thread-safe Bounded FIFO Queue pthread Hello
Posix Threads (Pthreads)
Posix Threads (Pthreads) Reference: Programming with POSIX Threads by David R. Butenhof, Addison Wesley, 1997 Threads: Introduction main: startthread( funk1 ) startthread( funk1 ) startthread( funk2 )
Lecture Outline. CS 5523 Operating Systems: Concurrency and Synchronization. a = 0; b = 0; // Initial state Thread 1. Objectives.
CS 5523 Operating Systems: Concurrency and Synchronization Thank Dr. Dakai Zhu and Dr. Palden Lama for providing their slides. Lecture Outline Problems with concurrent access to shared data Ø Race condition
real time operating systems course
real time operating systems course 4 introduction to POSIX pthread programming introduction thread creation, join, end thread scheduling thread cancellation semaphores thread mutexes and condition variables
Atomic Instructions! Hakim Weatherspoon CS 3410, Spring 2011 Computer Science Cornell University. P&H Chapter 2.11
Atomic Instructions! Hakim Weatherspoon CS 3410, Spring 2011 Computer Science Cornell University P&H Chapter 2.11 Announcements! PA4 due next, Friday, May 13 th Work in pairs Will not be able to use slip
EEE3052: Introduction to Operating Systems. Fall Project #3
EEE3052: Introduction to Operating Systems Fall 2017 Project #3 Project Plan 4 projects 0) Install Xv6 1) Process management 2) Virtual memory 3) Synchronization - Thread (11/13 ~ 11/21) - Mutex & Condition
W4118 Operating Systems. Instructor: Junfeng Yang
W4118 Operating Systems Instructor: Junfeng Yang Outline Semaphores Producer-consumer problem Monitors and condition variables 2 Semaphore motivation Problem with lock: mutual exclusion, but no ordering
Pthreads (2) Dong-kun Shin Embedded Software Laboratory Sungkyunkwan University Embedded Software Lab.
1 Pthreads (2) Dong-kun Shin Embedded Software Laboratory Sungkyunkwan University http://nyx.skku.ac.kr Last Class Review 2 ANSI/IEEE POSIX1003.1-95 Standard Thread management Work directly on threads
Resource Access Control (2) Real-Time and Embedded Systems (M) Lecture 14
Resource Access Control (2) Real-Time and Embedded Systems (M) Lecture 14 Lecture Outline Resources access control (cont d): Enhancing the priority ceiling protocol Stack-based priority ceiling protocol
Parallel Computing: Programming Shared Address Space Platforms (Pthread) Jin, Hai
Parallel Computing: Programming Shared Address Space Platforms (Pthread) Jin, Hai School of Computer Science and Technology Huazhong University of Science and Technology Thread Basics! All memory in the
Lecture 19: Shared Memory & Synchronization
Lecture 19: Shared Memory & Synchronization COMP 524 Programming Language Concepts Stephen Olivier April 16, 2009 Based on notes by A. Block, N. Fisher, F. Hernandez-Campos, and D. Stotts Forking int pid;
Network Programming TDC 561
Network Programming TDC 561 Lecture # 6: Multithreaded Servers Dr. Ehab S. Al-Shaer School of Computer Science & Telecommunication DePaul University Chicago, IL 1 Introduction to Multithreaded Network
CS 31: Intro to Systems Misc. Threading. Kevin Webb Swarthmore College December 6, 2018
CS 31: Intro to Systems Misc. Threading Kevin Webb Swarthmore College December 6, 2018 Classic thread patterns Agenda Pthreads primitives and examples of other forms of synchronization: Condition variables
A Brief Introduction to OS/2 Multithreading
A Brief Introduction to OS/2 Multithreading Jaroslav Kaƒer jkacer@kiv.zcu.cz University of West Bohemia Faculty of Applied Sciences Department of Computer Science and Engineering Why Use Parallelism? Performance
Week 3. Locks & Semaphores
Week 3 Locks & Semaphores Synchronization Mechanisms Locks Very primitive constructs with minimal semantics Semaphores A generalization of locks Easy to understand, hard to program with Condition Variables
Synchronising Threads
Synchronising Threads David Chisnall March 1, 2011 First Rule for Maintainable Concurrent Code No data may be both mutable and aliased Harder Problems Data is shared and mutable Access to it must be protected
LSN 13 Linux Concurrency Mechanisms
LSN 13 Linux Concurrency Mechanisms ECT362 Operating Systems Department of Engineering Technology LSN 13 Creating Processes fork() system call Returns PID of the child process created The new process is
Report on the Programming Language X10. Draft January 13, , Harlow, England, Addison-Wesley, Pearson education, ISBN-
621 Real-Time & Embedded 6 Systems 2015 Uwe R. Zimmer - The Australian National University 623 Overview methods Shared memory based synchronization Semaphores C, POSIX Dijkstra Conditional critical regions
Shared Memory Parallel Programming with Pthreads An overview
Shared Memory Parallel Programming with Pthreads An overview Part II Ing. Andrea Marongiu (a.marongiu@unibo.it) Includes slides from ECE459: Programming for Performance course at University of Waterloo
POSIX Threads. Paolo Burgio
POSIX Threads Paolo Burgio paolo.burgio@unimore.it The POSIX IEEE standard Specifies an operating system interface similar to most UNIX systems It extends the C language with primitives that allows the
Example. Example. Threading Language and Support. CS528 Multithreading: Programming with Threads. The boss/worker model. Thread Programming models
Threading Language and Support CS528 Multithreading: Programming with Threads A Sahu Dept of CSE, IIT Guwahati Pthread: POSIX thread Popular, Initial and Basic one Improved Constructs for threading c++
CS 450 Exam 2 Mon. 4/11/2016
CS 450 Exam 2 Mon. 4/11/2016 Name: Rules and Hints You may use one handwritten 8.5 11 cheat sheet (front and back). This is the only additional resource you may consult during this exam. No calculators.
Communication & Synchronization
Concurrent & Distributed 3Systems 2017 Communication & Synchronization Uwe R. Zimmer - The Australian National University References for this chapter [Ben-Ari06] M. Ben-Ari Principles of Concurrent and
PRINCIPLES OF OPERATING SYSTEMS
Department of Computer Science, University of Calgary PRINCIPLES OF OPERATING SYSTEMS Tutorial 9/10: Concurrency CPSC 457, Spring 2015 June 1-2, 2015 Announcement Midterm exam is rescheduled. The exam
Operating Systems (2INC0) 2017/18
Operating Systems (2INC0) 2017/18 Condition Synchronization (07) Dr. Courtesy of Prof. Dr. Johan Lukkien System Architecture and Networking Group Agenda Condition synchronization motivation condition variables
Synchronization. Dr. Yingwu Zhu
Synchronization Dr. Yingwu Zhu Synchronization Threads cooperate in multithreaded programs To share resources, access shared data structures Threads accessing a memory cache in a Web server To coordinate
More Types of Synchronization 11/29/16
More Types of Synchronization 11/29/16 Today s Agenda Classic thread patterns Other parallel programming patterns More synchronization primitives: RW locks Condition variables Semaphores Message passing
Programming Shared Address Space Platforms (Chapter 7)
Programming Shared Address Space Platforms (Chapter 7) Alexandre David 1.2.05 This is about pthreads. 1 Comparison Directive based: OpenMP. Explicit parallel programming: pthreads shared memory focus on
CS 471 Operating Systems. Yue Cheng. George Mason University Fall 2017
CS 471 Operating Systems Yue Cheng George Mason University Fall 2017 1 Review: Sync Terminology Worksheet 2 Review: Semaphores 3 Semaphores o Motivation: Avoid busy waiting by blocking a process execution
Review: Processes. A process is an instance of a running program. POSIX Thread APIs:
Review: Processes A process is an instance of a running program - A thread is an execution context - Process can have one or more threads - Threads share address space (code, data, heap), open files -
Multi-threaded Programming
Multi-threaded Programming Trifon Ruskov ruskov@tu-varna.acad.bg Technical University of Varna - Bulgaria 1 Threads A thread is defined as an independent stream of instructions that can be scheduled to
High-level Synchronization
Recap of Last Class High-level Synchronization CS 256/456 Dept. of Computer Science, University of Rochester Concurrent access to shared data may result in data inconsistency race condition. The Critical-Section
TCSS 422: OPERATING SYSTEMS
TCSS 422: OPERATING SYSTEMS OBJECTIVES Introduction to threads Concurrency: An Introduction Wes J. Lloyd Institute of Technology University of Washington - Tacoma Race condition Critical section Thread
Requeue PI: Making Glibc Condvars PI Aware
Requeue PI: Making Glibc Condvars PI Aware Darren Hart Special Thanks: Thomas Gleixner and Dinakar Guniguntala Agenda Introduction Test System Specifications Condvars 8 Way Intel Blade Futexes 2 socket
Programming with Shared Memory PART I. HPC Fall 2010 Prof. Robert van Engelen
Programming with Shared Memory PART I HPC Fall 2010 Prof. Robert van Engelen Overview Shared memory machines Programming strategies for shared memory machines Allocating shared data for IPC Processes and
Linux Programming
Linux Programming CMPT 433 Slides #6 Dr. B. Fraser 18-05-22 1 Topics 1) How can we do multitasking? 2) How can our multiple tasks communicate? 3) How can we communicate over the network? 18-05-22 2 Concurrency: