Chapter 5: Process Synchronization

Save this PDF as:

Size: px
Start display at page:

Transcription

1 Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013!

2 Chapter 5: Process Synchronization Background" The Critical-Section Problem" Petersons Solution" Synchronization Hardware" Mutex Locks" Semaphores" Classic Problems of Synchronization" Monitors" Synchronization Examples " Alternative Approaches" 5.2! Silberschatz, Galvin and Gagne 2013!

3 Objectives To introduce the critical-section problem, whose solutions can be used to ensure the consistency of shared data" To present both software and hardware solutions of the critical-section problem" To examine several classical process-synchronization problems" To explore several tools that are used to solve process synchronization problems" 5.3! Silberschatz, Galvin and Gagne 2013!

4 Background Processes can execute concurrently" May be interrupted at any time, partially completing execution" Concurrent access to shared data may result in data inconsistency" Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes" Illustration of the problem: Suppose that we wanted to provide a solution to the consumer-producer problem that fills all the buffers. We can do so by having an integer counter that keeps track of the number of full buffers. Initially, counter is set to 0. It is incremented by the producer after it produces a new buffer and is decremented by the consumer after it consumes a buffer." 5.4! Silberschatz, Galvin and Gagne 2013!

5 Producer while (true) { /* produce an item in next produced */ } while (counter == BUFFER SIZE) ; /* do nothing */ buffer[in] = next produced; in = (in + 1) % BUFFER SIZE; counter++; 5.5! Silberschatz, Galvin and Gagne 2013!

6 Consumer while (true) { while (counter == 0) ; /* do nothing */ next consumed = buffer[out]; out = (out + 1) % BUFFER SIZE; counter--; /* consume the item in next consumed */ } 5.6! Silberschatz, Galvin and Gagne 2013!

7 Race Condition counter++ could be implemented as register1 = counter register1 = register1 + 1 counter = register1 counter-- could be implemented as register2 = counter register2 = register2-1 counter = register2 Consider this execution interleaving with count = 5 initially:" "S0: producer executes register1 = counter {register1 = 5} S1: producer executes register1 = register1 + 1 {register1 = 6} S2: consumer executes register2 = counter {register2 = 5} S3: consumer executes register2 = register2 1 {register2 = 4} S4: producer executes counter = register1 {counter = 6} S5: consumer executes counter = register2 {counter = 4}" 5.7! Silberschatz, Galvin and Gagne 2013!

8 Critical Section Problem Consider system of n processes { P 0, P 1,, P n-1 }" Each process has a critical section segment of code" Process may be changing common variables, updating table, writing file, etc." When one process is in its critical section, no other may be executing in its critical section" Critical-section problem is to design a protocol to solve this" Each process must ask permission to enter its critical section in entry section, may follow critical section with exit section, the remaining code is in its remainder section! 5.8! Silberschatz, Galvin and Gagne 2013!

9 Critical Section General structure of process P i is" 5.9! Silberschatz, Galvin and Gagne 2013!

10 Solution to Critical-Section Problem 1. Mutual Exclusion - If process P i is executing in its critical section, then no other processes can be executing in their critical sections" 2. Progress - If no process is executing in its critical section and there exist some processes that wish to enter their critical section, then only the processes not in their remainder section can participate in the selection of the process that will enter its critical section next; the selection cannot be postponed indefinitely" 3. Bounded Waiting - A bound must exist on the number of times that other processes are allowed to enter their critical sections after a process has made a request to enter its critical section and before that request is granted" Assume that each process executes at a nonzero speed " No assumption concerning relative speed of the n processes" 5.10! Silberschatz, Galvin and Gagne 2013!

11 Solution to Critical-Section Problem Two approaches for handling critical sections in OSes, depending on if kernel is preemptive or nonpreemptive " Preemptive allows preemption of process when running in kernel mode" Specially difficult in multiprocessor architectures, but it makes the system more responsive" Non-preemptive runs until exits kernel mode, blocks, or voluntarily yields CPU" Essentially free of race conditions on kernel data structures in kernel mode, since only one active process in the kernel at a time" 5.11! Silberschatz, Galvin and Gagne 2013!

12 Peterson s Solution Good algorithmic description of solving the problem (but no guarantees for modern architectures)" Solution restricted to two processes in alternate execution (critical section and remainder section)" Assume that the load and store instructions are atomic; i.e., cannot be interrupted" The two processes share two variables:" int turn boolean flag[2] The variable turn indicates whose turn it is to enter its critical section" The flag array is used to indicate if a process is ready to enter its critical section" flag[i] == true implies that process Pi is ready to enter its critical section" Operating System Concepts 9th Edition! 5.12! Silberschatz, Galvin and Gagne 2013!

13 Algorithm for Process P i do { flag[i] = true; turn = j; while (flag[j] && turn == j); critical section flag[i] = false; remainder section } while (true); Provable that " 1. Mutual exclusion is preserved" 2. Progress requirement is satisfied" 3. Bounded-waiting requirement is met" 5.13! Silberschatz, Galvin and Gagne 2013!

14 Synchronization Hardware Many systems provide hardware support for critical section code" All solutions below based on idea of locking! Protecting critical regions via locks" Uniprocessors could disable interrupts" Currently running code would execute without preemption" Generally too inefficient on multiprocessor systems" Operating systems using this not broadly scalable" Modern machines provide special atomic hardware instructions" Atomic = non-interruptible" Either test memory word and set value" Or swap contents of two memory words" 5.14! Silberschatz, Galvin and Gagne 2013!

15 Solution to Critical-Section Problem Using Locks do { acquire lock critical section release lock remainder section } while (TRUE); 5.15! Silberschatz, Galvin and Gagne 2013!

16 Solution using test_and_set() Two test_and_set() cannot be executed simultaneously" Shared boolean variable lock, initialized to FALSE" Solution:" boolean test_and_set(boolean *target) { boolean rv = *target; *target = TRUE; return rv: } do { while (test_and_set(&lock)) ; /* do nothing */ /* critical section */ lock = false; /* remainder section */ } while (true); 5.16! Silberschatz, Galvin and Gagne 2013!

17 compare_and_swap Instruction Definition:" int compare_and_swap(int *value, int expected, int new_value) { int temp = *value; if (*value == expected) *value = new_value; return temp; } 5.17! Silberschatz, Galvin and Gagne 2013!

18 Solution using compare_and_swap Shared boolean variable lock initialized to FALSE" Each process has a local boolean variable key Solution:" do { while (compare_and_swap(&lock, 0, 1)!= 0) //value,expected,new ; /* do nothing */ /* critical section */ lock = 0; /* remainder section */ } while (true); 5.18! Silberschatz, Galvin and Gagne 2013!

19 Bounded-waiting Mutual Exclusion with test_and_set do { waiting[i] = true; key = true; while (waiting[i] && key) key = test_and_set(&lock); //only first lock==false will set key=false waiting[i] = false; /* critical section */ j = (i + 1) % n; while ((j!= i) &&!waiting[j]) j = (j + 1) % n; if (j == i) else lock = false; //look for the next P[j] waiting: bound-waiting req. waiting[j] = false; //wakeup only one process P[j] without releasing lock /* remainder section */ } while (true); 5.19! Silberschatz, Galvin and Gagne 2013!

20 Mutex Locks Previous solutions are complicated and generally inaccessible to application programmers" OS designers build software tools to solve critical section problem" Simplest synchronization is done with mutex lock" Protect critical regions by first acquire() a lock (then all other processes attempting to get the lock are blocked), and then release() it" Boolean variable indicating if lock is available or not" acquire() { while (!available) ; /* busy wait */ available = false; } release() { available = true; do { acquire lock critical section release lock remainder section } while (true); } Operating System Concepts 9th Edition! 5.20! Silberschatz, Galvin and Gagne 2013!

21 Mutex Locks Calls to acquire() and release() must be atomic" Usually implemented via hardware atomic instructions" But this solution requires busy waiting! All other processes trying to get the lock must continuously loop" This lock is therefore called a spinlock! Very wasteful of CPU cycles" Might still be more efficient than (costly) context switches for shorter wait times" 5.21! Silberschatz, Galvin and Gagne 2013!

22 Semaphore Synchronization tool that does not require busy waiting! Semaphore S integer variable" Two standard operations modify S : wait() and signal() Less complicated" Can only be accessed via two indivisible (atomic) operations" wait (S) { while (S <= 0) ; // busy wait S--; } signal (S) { S++; } Operating System Concepts 9th Edition! 5.22! Silberschatz, Galvin and Gagne 2013!

23 Semaphore Usage Counting semaphore integer value can range over an unrestricted domain" Binary semaphore integer value can range only between 0 and 1" Then equivalent to a mutex lock! Can solve various synchronization problems" Consider P1 and P2 that require S1 to happen before S2! P 1: S 1; signal(synch); //sync++ has added one resource wait(synch); //executed only when synch is > 0 P 2: S 2; " Operating System Concepts 9th Edition! 5.23! Silberschatz, Galvin and Gagne 2013!

24 Semaphore Implementation Must guarantee that no two processes can execute wait() and signal() on the same semaphore at the same time" Thus, implementation becomes the critical section problem, where the wait and signal codes are placed in the critical section" Could now have busy waiting in critical section implementation" But implementation code is short" Little busy waiting if critical section rarely occupied" Note that applications may spend lots of time in critical sections and therefore this is not a good solution" Operating System Concepts 9th Edition! 5.24! Silberschatz, Galvin and Gagne 2013!

25 Semaphore Implementation with no Busy Waiting With each semaphore there is an associated waiting queue" Each entry in a waiting queue has two data items:" value (of type integer)" pointer to next record in the list" typedef struct { int value; struct process *list; } semaphore; Two operations:" block place the process invoking the operation in the appropriate waiting queue" wakeup remove one of the processes in the waiting queue and place it in the ready queue" wait(semaphore *S) { S->value--; if (S->value < 0) { add this process to S->list; block(); } } signal(semaphore *S) { S->value++; if (S->value <= 0) { remove a process P from S->list; wakeup(p); } } 5.25! Silberschatz, Galvin and Gagne 2013!

26 Deadlock and Starvation Deadlock two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes" Let! S and Q be two semaphores initialized to 1"! P0 wait(s); //exec 1st wait(q); //exec 3rd... signal(s); signal(q); " wait(q); wait(s); P1! //exec 2nd //exec 4th... signal(q); signal(s); Starvation indefinite blocking! A process may never be removed from the semaphore queue in which it is suspended" Operating System Concepts 9th Edition! 5.26! Silberschatz, Galvin and Gagne 2013!

27 Priority Inversion Scheduling problem when lower-priority process holds a lock needed by higher-priority process" Scenario :" Processes with priorities L < M < H request resource r! L first locks on r ; then H requests r, but must wait until L ends" In the meantime, M requests r and preempts L" H is waiting longer for lower-priority processes" Not a problem with only two levels of priorities, but two levels are insufficient for most OSes" Solved via priority-inheritance protocol! All lower-priority processes with a resource requested by a higher-priority process, inherits the higher-priority level until it releases the resource" 5.27! Silberschatz, Galvin and Gagne 2013!

28 Classical Problems of Synchronization Classical problems used to test newly-proposed synchronization schemes" Bounded-Buffer Problem" Readers and Writers Problem" Dining-Philosophers Problem" 5.28! Silberschatz, Galvin and Gagne 2013!

29 Bounded-Buffer Problem Shared data structures:" n buffers, each can hold one item" Semaphore mutex initialized to the value 1" Semaphore full initialized to the value 0" Semaphore empty initialized to the value n! The structure of the producer process do { The structure of the consumer process" do {... /* produce an item in next_produced */... wait(empty); wait(full); wait(mutex);... /* remove an item from buffer to next_consumed */ wait(mutex);... /* add next_produced to the buffer */... signal(mutex);... signal(mutex); signal(empty);... /* consume the item in next_consumed */ signal(full); } while (true); Operating System Concepts 9th Edition!... } while (true); 5.29! Silberschatz, Galvin and Gagne 2013!

31 Readers-Writers Problem do { Shared data" Data set" Semaphore rw_mutex initialized to 1" Semaphore mutex initialized to 1" Integer read_count initialized to 0" The structure of a writer process" wait(rw_mutex);... /* writing is performed */... signal(rw_mutex); } while (true); The structure of a reader process " do { wait(mutex); read_count++; if (read_count == 1) wait(rw_mutex); signal(mutex);... /* reading is performed */... wait(mutex); read_count--; if (read_count == 0) signal(rw_mutex); signal(mutex); } while (true); 5.31! Silberschatz, Galvin and Gagne 2013!

32 Dining-Philosophers Problem Philosophers spend their lives thinking and eating" They do not interact with their neighbors, occasionally try to pick up 2 chopsticks (one at a time, on either side) to eat from bowl" Need both chopsticks to eat" Put back in their place both chopsticks when done eating" Shared data for 5 philosophers" Bowl of rice (data set)" Semaphore chopstick[5] initialized to 1" do The structure of Philosopher i :" { wait(chopstick[i]); wait(chopstick[(i+1)%5]); // eat signal(chopstick[i]); signal(chopstick[(i+1)%5]); // think } while (TRUE); Operating System Concepts 9th Edition! 5.32! What is the problem with this algorithm?" Silberschatz, Galvin and Gagne 2013!

33 Problems with Semaphores Incorrect use of semaphore operations can be difficult to detect, e.g. :" Inversed order: signal(mutex)... wait(mutex) Repeated calls: wait(mutex)... wait(mutex)" Omitted calls: wait(mutex) or signal(mutex) (or both)" Results in deadlock and/or starvation" 5.33! Silberschatz, Galvin and Gagne 2013!

34 Monitors A high-level abstraction that provides a convenient and effective mechanism for process synchronization" Abstract data type, internal variables only accessible by code within the procedure" Only one process may be active within the monitor at a time" But not powerful enough to model some synchronization schemes" monitor monitor-name { // shared variable declarations function P1(...) {... }... function Pn(...) {... } initialization_code (...) {... } } Operating System Concepts 9th Edition! 5.34! Silberschatz, Galvin and Gagne 2013!

35 Condition Variables Synchronization mechanism for monitors declared as variables:" condition x, y;" Only two operations can be invoked on a condition variable:" x.wait() x.signal() resumes one of processes (if any) that invoked x.wait() a process that invokes the operation is suspended until x.signal() If no x.wait() on the condition variable, then it has no effect on the variable" Operating System Concepts 9th Edition! 5.35! Silberschatz, Galvin and Gagne 2013!

36 Condition Variables Choices If process P invokes x.signal(), with Q in x.wait() state, what should happen next?" If Q is resumed, then P must wait, otherwise two processes would be active in the monitor" Options include" Signal and wait P waits until Q leaves monitor or waits for another condition" Signal and continue Q waits until P leaves the monitor or waits for another condition" Both have pros and cons language implementer can decide" Monitors implemented in Concurrent Pascal compromise" P executing signal immediately leaves the monitor, Q is resumed" Implemented in other languages including Mesa, C#, Java" 5.36! Silberschatz, Galvin and Gagne 2013!

37 Solution to Dining Philosophers monitor DiningPhilosophers { enum { THINKING; HUNGRY, EATING) state[5]; condition self[5]; void pickup(int i) { state[i] = HUNGRY; test(i); if (state[i]!= EATING) self[i].wait(); } void putdown(int i) { state[i] = THINKING; // test left and right neighbors test((i+4)%5); test((i+1)%5); } } void test(int i) { if ((state[(i+4)%5]!= EATING) && (state[i] == HUNGRY) && (state[(i+1)%5]!= EATING) ) { state[i] = EATING; self[i].signal(); } } initialization_code() { for (int i = 0; i < 5; i++) state[i] = THINKING; } 5.37! Silberschatz, Galvin and Gagne 2013!

38 Solution to Dining Philosophers (cont.) Each philosopher i invokes the operations pickup() and putdown() in the following sequence:" DiningPhilosophers.pickup(i);... EAT... DiningPhilosophers.putdown(i); No deadlocks, but starvation is possible" Operating System Concepts 9th Edition! 5.38! Silberschatz, Galvin and Gagne 2013!

39 Monitor Implementation Using Semaphores Variables " "semaphore mutex; // (initially semaphore next; // (initially int next_count = 0; = 1) = 0) Each external function F will be replaced by" "wait(mutex);... body of F;... if (next_count > 0) signal(next); else signal(mutex); Mutual exclusion within a monitor is ensured" Operating System Concepts 9th Edition! 5.39! Silberschatz, Galvin and Gagne 2013!

40 Monitor Implementation Condition Variables For each condition variable x, we have:" "semaphore x_sem; int x_count = 0; // (initially = 0) The operation x.wait() can be implemented as:" " "" "x_count++; if (next_count > 0) signal(next); else signal(mutex); wait(x_sem); x_count--; The operation x.signal() can be implemented as: "if (x_count > 0) { next_count++; signal(x_sem); wait(next); next_count--; } Operating System! Concepts 9th Edition!!! 5.40! Silberschatz, Galvin and Gagne 2013!

41 Resuming Processes within a Monitor If several processes queued on condition x, and x.signal() executed, which one should be resumed?" First-come, first-served (FCFS) frequently not adequate " conditional-wait construct of the form x.wait(c) where c is priority number! Process with lowest number (highest priority) is scheduled next" Example of ResourceAllocator, next" 5.41! Silberschatz, Galvin and Gagne 2013!

42 A Monitor to Allocate Single Resource monitor ResourceAllocator { boolean busy; condition x; void acquire(int time) { if (busy) x.wait(time); //time: maximum time it will keep resource busy = TRUE; } void release() { busy = FALSE; x.signal(); } initialization_code() { busy = FALSE; } }! "" 5.42! Silberschatz, Galvin and Gagne 2013!

43 Synchronization Examples Windows XP" Solaris" Linux" Pthreads" 5.43! Silberschatz, Galvin and Gagne 2013!

44 Windows XP Synchronization Uses interrupt masks to protect access to global resources on uniprocessor systems" Uses spinlocks on multiprocessor systems" Spinlocking-thread will never be preempted" Also provides dispatcher objects user-land (outside the kernel) which may act as mutex locks, semaphores, events, and timers" Event acts much like a condition variable (notify thread(s) when condition occurs)" Timer notifies one or more threads when specified amount of time has expired" Dispatcher objects either signaled-state (object available) or non-signaled state (thread will block)" 5.44! Silberschatz, Galvin and Gagne 2013!

46 Linux Synchronization Linux:" Prior to kernel Version 2.6, disables interrupts to implement short critical sections" Version 2.6 and later, fully preemptive" Linux provides:" semaphores" spinlocks" reader-writer versions of both" On single-cpu system, spinlocks replaced by enabling and disabling kernel preemption" 5.46! Silberschatz, Galvin and Gagne 2013!

47 Pthreads Synchronization Pthreads API is OS-independent" It provides:" mutex locks" condition variables Non-portable extensions include:" read-write locks" spinlocks" 5.47! Silberschatz, Galvin and Gagne 2013!

48 Alternatives to Thread-safe Concurrent Applications Transactional memory" OpenMP" Functional programming languages" 5.48! Silberschatz, Galvin and Gagne 2013!

49 Transactional Memory Assures that operations happen as a single logical unit of work, in its entirety, or not at all" Related to the field of database systems" Challenge is assuring atomicity, despite computer system failures" Transaction - collection of instructions or operations that performs single logical function" Here we are concerned with changes to stable storage disk" Transaction is series of read and write operations" Terminated by commit (transaction successful) or abort (transaction failed) operation" Aborted transaction must be rolled back to undo any changes it performed" In software, compiler is responsible to identify the concurrent sections of the code and to augment them with proper lock mechanisms" In hardware, implemented as cache hierarchies, and cache coherency mechanisms" Transactional memory is not widespread yet, but " 5.49! Silberschatz, Galvin and Gagne 2013!

50 OpenMP Indicates where in the code only one thread may be active at a time" similar to a mutex lock" Special compiler instruction" #pragma omp critical Programmer must still handle race conditions and deadlocks" 5.50! Silberschatz, Galvin and Gagne 2013!

51 Functional Languages E.g.: Erlang, Scala" Functional languages do not maintain state" Once a variable is assigned a value, it cannot change anymore" No such problems as race conditions and deadlocks" Therefore suitable for concurrent/parallel programming on multicores" 5.51! Silberschatz, Galvin and Gagne 2013!

52 End of Chapter 5 Silberschatz, Galvin and Gagne 2013!

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition

Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks

Chapter 6: Process Synchronization

Module 6: Process Synchronization Chapter 6: Process Synchronization Background! The Critical-Section Problem! Peterson s Solution! Synchronization Hardware! Semaphores! Classic Problems of Synchronization!

Chapter 7: Process Synchronization. Background. Illustration

Chapter 7: Process Synchronization Background The Critical-Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization Critical Regions Monitors Synchronization in Solaris

CS370 Operating Systems

CS370 Operating Systems Colorado State University Yashwant K Malaiya Fall 2017 Lecture 12 Slides based on Text by Silberschatz, Galvin, Gagne Various sources 1 1 FAQ 2 Mutex vs Semaphore Mutex is binary,

Chapter 6 Synchronization

Chapter 6 Synchronization Da-Wei Chang CSIE.NCKU Source: Abraham Silberschatz, Peter B. Galvin, and Greg Gagne, "Operating System Concepts", 9th Edition, Wiley. 1 Outline Background The Critical-Section

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

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition

Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Objectives To present the concept of process synchronization. To introduce the critical-section problem, whose solutions can be used

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

Chapter 6 Process Synchronization

Chapter 6 Process Synchronization Cooperating Process process that can affect or be affected by other processes directly share a logical address space (threads) be allowed to share data via files or messages

Synchronization. Race Condition. The Critical-Section Problem Solution. The Synchronization Problem. Typical Process P i. Peterson s Solution

Race Condition Synchronization CSCI 315 Operating Systems Design Department of Computer Science A race occurs when the correctness of a program depends on one thread reaching point x in its control flow

Lecture 3: Synchronization & Deadlocks Background Concurrent access to shared data may result in data inconsistency Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating

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

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

Background. Module 6: Process Synchronization. Bounded-Buffer (Cont.) Bounded-Buffer. Background

Module 6: Process Synchronization Background Background The Critical-Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization Critical Regions Monitors Synchronization

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

Process Co-ordination OPERATING SYSTEMS

OPERATING SYSTEMS Prescribed Text Book Operating System Principles, Seventh Edition By Abraham Silberschatz, Peter Baer Galvin and Greg Gagne 1 PROCESS - CONCEPT Processes executing concurrently in the

Process Coordination

Process Coordination Why is it needed? Processes may need to share data More than one process reading/writing the same data (a shared file, a database record, ) Output of one process being used by another

Process Synchronization

Process Synchronization Mandar Mitra Indian Statistical Institute M. Mitra (ISI) Process Synchronization 1 / 28 Cooperating processes Reference: Section 4.4. Cooperating process: shares data with other

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

\$ %! 0,-./ + %/ 0"/ C (" &() + A &B' 7! .+ N!! O8K + 8 N. (Monitors) 3+!

"#! \$ %! *+ &' & "-/ &+, :/!! &+ 8/!.!"!! > &, < &+ 7!! "-/ :/= +. :/= 0 0/ 7!@?+ C (" & + A &B' 7! G' 3/ 0"=' 7> H 0 4 0! &D E.! 0 n I"2 &+ % &B' 0!!! n 1 + counter J " &B' & K n

COP 4225 Advanced Unix Programming. Synchronization. Chi Zhang

COP 4225 Advanced Unix Programming Synchronization Chi Zhang czhang@cs.fiu.edu 1 Cooperating Processes Independent process cannot affect or be affected by the execution of another process. Cooperating

Concurrency: Mutual Exclusion and

Concurrency: Mutual Exclusion and Synchronization 1 Needs of Processes Allocation of processor time Allocation and sharing resources Communication among processes Synchronization of multiple processes

CS370 Opera;ng Systems Midterm Review. Yashwant K Malaiya Spring 2018

CS370 Opera;ng Systems Midterm Review Yashwant K Malaiya Spring 2018 1 1 Computer System Structures Computer System Opera2on Stack for calling func2ons (subrou2nes) I/O Structure: polling, interrupts,

Process Synchronization

Process Synchronization Reading: Silberschatz chapter 6 Additional Reading: Stallings chapter 5 EEL 358 1 Outline Concurrency Competing and Cooperating Processes The Critical-Section Problem Fundamental

Process Synchronization

Process Synchronization Concurrent access to shared data in the data section of a multi-thread process, in the shared memory of multiple processes, or in a shared file Although every example in this chapter

9/29/2014. CS341: Operating System Mid Semester Model Solution Uploaded Semaphore ADT: wait(), signal()

CS341: Operating System Mid Semester Model Solution Uploaded Semaphore ADT: wait(), signal() Lect23: 30 th Sept 2014 Dr. A. Sahu Dept of Comp. Sc. & Engg. Indian Institute of Technology Guwahati Classical

Roadmap. Tevfik Ko!ar. CSC Operating Systems Fall Lecture - XI Deadlocks - II. Louisiana State University

CSC 4103 - Operating Systems Fall 2009 Lecture - XI Deadlocks - II Tevfik Ko!ar Louisiana State University September 29 th, 2009 1 Roadmap Classic Problems of Synchronization Bounded Buffer Readers-Writers

Semaphores (by Dijkstra)

CSCI 4401 Principles of Operating Systems I Process Synchronization II: Classic Problems Vassil Roussev vassil@cs.uno.edu Semaphores (by Dijkstra) A higher-level way of doing synchronization between threads/processes

Process Management And Synchronization

Process Management And Synchronization In a single processor multiprogramming system the processor switches between the various jobs until to finish the execution of all jobs. These jobs will share the

Process Synchronization. Mehdi Kargahi School of ECE University of Tehran Spring 2008

Process Synchronization Mehdi Kargahi School of ECE University of Tehran Spring 2008 Producer-Consumer (Bounded Buffer) Producer Consumer Race Condition Producer Consumer Critical Sections Structure of

CS3733: Operating Systems

Outline CS3733: Operating Systems Topics: Synchronization, Critical Sections and Semaphores (SGG Chapter 6) Instructor: Dr. Tongping Liu 1 Memory Model of Multithreaded Programs Synchronization for coordinated

Synchronization Spinlocks - Semaphores

CS 4410 Operating Systems Synchronization Spinlocks - Semaphores Summer 2013 Cornell University 1 Today How can I synchronize the execution of multiple threads of the same process? Example Race condition

Semaphores. Jinkyu Jeong Computer Systems Laboratory Sungkyunkwan University

Semaphores 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) Synchronization

QUESTION BANK. UNIT II: PROCESS SCHEDULING AND SYNCHRONIZATION PART A (2 Marks)

QUESTION BANK DEPARTMENT: EEE SEMESTER VII SUBJECT CODE: CS2411 SUBJECT NAME: OS UNIT II: PROCESS SCHEDULING AND SYNCHRONIZATION PART A (2 Marks) 1. What is deadlock? (AUC NOV2010) A deadlock is a situation

9/30/2014. CS341: Operating System High Level Construct: Monitor Deadlock Conditions Prevention, Avoidance Detection and Recovery

CS341: Operating System High Level Construct: Monitor Conditions Prevention, Avoidance Detection and Recovery Lect24: 1 st Oct 2014 Dr. A. Sahu Dept of Comp. Sc. & Engg. Indian Institute of Technology

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

CSE325 Principles of Operating Systems Process/Thread Synchronization David Duggan dduggan@sandia.gov March 1, 2011 The image cannot be displayed. Your computer may not have enough memory to open the image,

Concurrency. Chapter 5

Concurrency 1 Chapter 5 2 Concurrency Is a fundamental concept in operating system design Processes execute interleaved in time on a single processor Creates the illusion of simultaneous execution Benefits

Recap: Thread. What is it? What does it need (thread private)? What for? How to implement? Independent flow of control. Stack

What is it? Recap: Thread Independent flow of control What does it need (thread private)? Stack What for? Lightweight programming construct for concurrent activities How to implement? Kernel thread vs.

Module 5: Process Synchronization. Reading: Chapter 6

Module 5: Process Synchronization Reading: Chapter 6 1 Solutions Classic problems What is the problem? Process Synchronization Synchr. In Real Systems 2 Background Producer/Consumer Critical Section Problem

Lecture 9: Thread Synchronizations. Spring 2016 Jason Tang

Lecture 9: Thread Synchronizations Spring 2016 Jason Tang Slides based upon Operating System Concept slides, http://codex.cs.yale.edu/avi/os-book/os9/slide-dir/index.html Copyright Silberschatz, Galvin,

Operating Systems. Operating Systems Summer 2017 Sina Meraji U of T

Operating Systems Operating Systems Summer 2017 Sina Meraji U of T More Special Instructions Swap (or Exchange) instruction Operates on two words atomically Can also be used to solve critical section problem

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

Lecture Topics. Announcements. Today: Concurrency (Stallings, chapter , 5.7) Next: Exam #1. Self-Study Exercise #5. Project #3 (due 9/28)

Lecture Topics Today: Concurrency (Stallings, chapter 5.1-5.4, 5.7) Next: Exam #1 1 Announcements Self-Study Exercise #5 Project #3 (due 9/28) Project #4 (due 10/12) 2 Exam #1 Tuesday, 10/3 during lecture

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

OS Process Synchronization!

OS Process Synchronization! Race Conditions! The Critical Section Problem! Synchronization Hardware! Semaphores! Classical Problems of Synchronization! Synchronization HW Assignment! 3.1! Concurrent Access

Synchronization COMPSCI 386

Synchronization COMPSCI 386 Obvious? // push an item onto the stack while (top == SIZE) ; stack[top++] = item; // pop an item off the stack while (top == 0) ; item = stack[top--]; PRODUCER CONSUMER Suppose

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

Chapter 5 Asynchronous Concurrent Execution

Chapter 5 Asynchronous Concurrent Execution Outline 5.1 Introduction 5.2 Mutual Exclusion 5.2.1 Java Multithreading Case Study 5.2.2 Critical Sections 5.2.3 Mutual Exclusion Primitives 5.3 Implementing

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

Examples of OS Kernel Synchronization More on Synchronization and Deadlock Two processes making system calls to read/write on the same file, leading to possible race condition on the file system data structures

Mutual Exclusion and Synchronization

Mutual Exclusion and Synchronization Concurrency Defined Single processor multiprogramming system Interleaving of processes Multiprocessor systems Processes run in parallel on different processors Interleaving

Interprocess Communication 11

Interprocess Communication 11 Only a brain-damaged operating system would support task switching and not make the simple next step of supporting multitasking. Calvin Keegan Processes Abstraction of a running

Synchronization. Disclaimer: some slides are adopted from the book authors slides with permission 1

Synchronization Disclaimer: some slides are adopted from the book authors slides with permission 1 What is it? Recap: Thread Independent flow of control What does it need (thread private)? Stack What for?

Process Synchronization

Process Synchronization Basic Concepts Objectives To introduce the critical-section problem, to ensure the consistency of shared data To introduce the concept of an atomic transaction and describe mechanisms

CSE 120. Fall Lecture 6: Semaphores. Keith Marzullo

CSE 120 Principles of Operating Systems Fall 2007 Lecture 6: Semaphores Keith Marzullo Announcements Homework #2 out Homework #1 almost graded... Discussion session on Wednesday will entertain questions

Chapter 2 Processes and Threads. Interprocess Communication Race Conditions

Chapter 2 Processes and Threads [ ] 2.3 Interprocess communication 2.4 Classical IPC problems 2.5 Scheduling 85 Interprocess Communication Race Conditions Two processes want to access shared memory at

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

Synchronization API of Pthread Mutex: lock, unlock, try_lock CondVar: wait, signal, signal_broadcast. Synchronization

CS341: Operating System Lect20 : 16 th Sept 2014 Dr. A. Sahu Dept of Comp. Sc. & Engg. Indian Institute of Technology Guwahati Synchronization API of Pthread Mutex: lock, unlock, try_lock CondVar: wait,

Operating Systems. User OS. Kernel & Device Drivers. Interface Programs. Interprocess Communication (IPC)

Operating Systems User OS Kernel & Device Drivers Interface Programs Interprocess Communication (IPC) Brian Mitchell (bmitchel@mcs.drexel.edu) - Operating Systems 1 Interprocess Communication Shared Memory

Chapter 7: Deadlocks CS370 Operating Systems

Chapter 7: Deadlocks CS370 Operating Systems Objectives: Description of deadlocks, which prevent sets of concurrent processes from completing their tasks Different methods for preventing or avoiding deadlocks

Deadlock and Monitors. CS439: Principles of Computer Systems February 7, 2018

Deadlock and Monitors CS439: Principles of Computer Systems February 7, 2018 Last Time Terminology Safety and liveness Atomic Instructions, Synchronization, Mutual Exclusion, Critical Sections Synchronization

Chapter 6 Concurrency: Deadlock and Starvation

Operating Systems: Internals and Design Principles Chapter 6 Concurrency: Deadlock and Starvation Seventh Edition By William Stallings Operating Systems: Internals and Design Principles When two trains

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

Concurrency: Deadlock and Starvation. Chapter 6

Concurrency: Deadlock and Starvation Chapter 6 Deadlock Permanent blocking of a set of processes that either compete for system resources or communicate with each other Involve conflicting needs for resources

Techno India Batanagar Department of Computer Science & Engineering. Model Questions. Multiple Choice Questions:

Techno India Batanagar Department of Computer Science & Engineering Model Questions Subject Name: Operating System Multiple Choice Questions: Subject Code: CS603 1) Shell is the exclusive feature of a)

Chapter 3: Process-Concept. Operating System Concepts 8 th Edition,

Chapter 3: Process-Concept, Silberschatz, Galvin and Gagne 2009 Chapter 3: Process-Concept Process Concept Process Scheduling Operations on Processes Interprocess Communication 3.2 Silberschatz, Galvin

CSE Traditional Operating Systems deal with typical system software designed to be:

CSE 6431 Traditional Operating Systems deal with typical system software designed to be: general purpose running on single processor machines Advanced Operating Systems are designed for either a special

Achieving Synchronization or How to Build a Semaphore

Achieving Synchronization or How to Build a Semaphore CS 241 March 12, 2012 Copyright University of Illinois CS 241 Staff 1 Announcements MP5 due tomorrow Jelly beans... Today Building a Semaphore If time:

ENGR 3950U / CSCI 3020U UOIT, Fall 2012 Quiz on Process Synchronization SOLUTIONS

Name: Student Number: SOLUTIONS ENGR 3950U / CSCI 3020U (Operating Systems) Quiz on Process Synchronization November 13, 2012, Duration: 40 Minutes (10 questions and 8 pages, 45 Marks) Instructor: Dr.

Chapter 7: Deadlocks. Operating System Concepts 9 th Edition

Concepts to discuss Deadlock CSCI 315 Operating Systems Design Department of Computer Science Deadlock Livelock Spinlock vs. Blocking Notice: The slides for this lecture have been largely based on those

Synchronization. CSCI 3753 Operating Systems Spring 2005 Prof. Rick Han

Synchronization CSCI 3753 Operating Systems Spring 2005 Prof. Rick Han Announcements HW #3 is coming, due Friday Feb. 25, a week+ from now PA #2 is coming, assigned about next Tuesday Midterm is tentatively

Synchronization Classic Problems

CS 4410 Operating Systems Synchronization Classic Problems Summer 2013 Cornell University 1 Today What practical problems can we solve with semaphores? Bounded-Buffer Problem Producer-Consumer Problem

Chapter 5 Concurrency: Mutual Exclusion and Synchronization

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

Concurrency pros and cons. Concurrent Programming Problems. Linked list example. Linked list example. Mutual Exclusion. Concurrency is good for users

Concurrency pros and cons Con Programming Problems OS Spring 2011 Concurrency is good for users One of the reasons for multiprogramming Working on the same problem, simultaneous execution of programs,

CS 5523: Operating Systems

CS 5523: Operating Systems Instructor: Dr. Tongping Liu Midterm Exam: Oct 6, 2015, Tuesday 7:15pm 8:30pm CS5523: Operating Systems @ UTSA 1 Lecture1: OS Overview Operating System: what is it?! Evolution

Synchronization. Peter J. Denning CS471/CS571. Copyright 2001, by Peter Denning

Synchronization Peter J. Denning CS471/CS571 Copyright 2001, by Peter Denning What is synchronization? Requirement that one process stop to wait to pass a point until another process sends a signal. The

Operating Systems. Synchronization

Operating Systems Fall 2014 Synchronization Myungjin Lee myungjin.lee@ed.ac.uk 1 Temporal relations Instructions executed by a single thread are totally ordered A < B < C < Absent synchronization, instructions

Synchronization. CS61, Lecture 18. Prof. Stephen Chong November 3, 2011

Synchronization CS61, Lecture 18 Prof. Stephen Chong November 3, 2011 Announcements Assignment 5 Tell us your group by Sunday Nov 6 Due Thursday Nov 17 Talks of interest in next two days Towards Predictable,

What are they? How do we represent them? Scheduling Something smaller than a process? Threads Synchronizing and Communicating Classic IPC problems

Processes What are they? How do we represent them? Scheduling Something smaller than a process? Threads Synchronizing and Communicating Classic IPC problems Processes The Process Model a) Multiprogramming

Thread. Disclaimer: some slides are adopted from the book authors slides with permission 1

Thread Disclaimer: some slides are adopted from the book authors slides with permission 1 IPC Shared memory Recap share a memory region between processes read or write to the shared memory region fast

IT 540 Operating Systems ECE519 Advanced Operating Systems

IT 540 Operating Systems ECE519 Advanced Operating Systems Prof. Dr. Hasan Hüseyin BALIK (5 th Week) (Advanced) Operating Systems 5. Concurrency: Mutual Exclusion and Synchronization 5. Outline Principles

Resource Allocation and Deadlock Handling What s in a deadlock Deadlock: A set of blocked processes each waiting for an event (e.g. a resource to become available) that only another process in the set

Deadlocks & Deadlock Prevention James Moscola Department of Physical Sciences York College of Pennsylvania Based on Operating System Concepts, 9th Edition by Silberschatz, Galvin, Gagne The Deadlock Problem

Synchronization. CSCI 5103 Operating Systems. Semaphore Usage. Bounded-Buffer Problem With Semaphores. Monitors Other Approaches

Synchronization CSCI 5103 Operating Systems Monitors Other Approaches Instructor: Abhishek Chandra 2 3 Semaphore Usage wait(s) Critical section signal(s) Each process must call wait and signal in correct

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

Chapter 4: Threads. Operating System Concepts 9 th Edit9on

Chapter 4: Threads Operating System Concepts 9 th Edit9on Silberschatz, Galvin and Gagne 2013 Chapter 4: Threads 1. Overview 2. Multicore Programming 3. Multithreading Models 4. Thread Libraries 5. Implicit

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

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