Concurrency Mutual Exclusion and Synchronization Chapter 5 1
- Slides: 60
Concurrency: Mutual Exclusion and Synchronization Chapter 5 1
Concurrency • Why Important? – We have multiple programs running at the same time. • Difficulties: – Shared memory access. – Managing the I/O device access 2
Operating System Concerns • Keep track of various processes • Allocate and deallocate resources – – Processor time Memory Files I/O devices • Protect data and resources • Output of process must be independent of the speed of execution of other concurrent processes 3
Difficulties of Concurrency • Sharing of global resources • Operating system managing the allocation of resources optimally • Difficult to locate programming errors – Because we can’t control how everything is going to be timed can be very difficult to duplicate an error. 4
Three Main Types of Concurrent Processes • Processes unaware of each other – Have no access or relation. • Processes indirectly aware of each other – Share some data or an object, but don’t have direct access to each other. • Process directly aware of each other – Have direct access to each other. 5
6
A Simple Example void echo() { chin = getchar(); chout = chin; putchar(chout); } 7
A Simple Example Process P 1. chin = getchar(); . chout = chin; putchar(chout); . . Process P 2. . chin = getchar(); chout = chin; . putchar(chout); . 8
Mutual Exclusion • What would be some basic rules? – Make sure the processes don’t interfere with each other. (Only one process allowed in the critical section at a time. ) – Finite length critical sections (can’t stay there forever). 9
Requirements for Mutual Exclusion • Only one process at a time is allowed in the critical section for a resource • A process that halts in its noncritical section must do so without interfering with other processes • No deadlock or starvation 10
Requirements for Mutual Exclusion • A process must not be delayed access to a critical section when there is no other process using it • No assumptions are made about relative process speeds or number of processes • A process remains inside its critical section for a finite time only 11
Mutual Exclusion: Hardware Support • Interrupt Disabling – A process runs until it invokes an operating system service or until it is interrupted – Disabling interrupts guarantees mutual exclusion – Processor is limited in its ability to interleave programs – Multiprocessing • disabling interrupts on one processor will not guarantee mutual exclusion 12
Mutual Exclusion: Hardware Support • Special Machine Instructions – Performed in a single instruction cycle – Access to the memory location is blocked for any other instructions • Why is this important? – We can’t have instructions getting interwoven. 13
Peterson’s Algorithm Boolean flag[2]; Int turn; Void P 0() { while (true) { flag[0]=true; turn = 1; while (flag[1] && turn==1) /** do nothing **/ /** crit section **/ flag [0] = false; } } 14
Peterson’s Algorithm Boolean flag[2]; Int turn; Void P 1() { while (true) { flag[1]=true; turn = 0; while (flag[0] && turn==0) /** do nothing **/ /** crit section **/ flag [1] = false } } 15
Homework • Extend Peterson’s Algorithm to work with 3 processes. • Due Wed Feb 16 th 16
Message Passing • Methods: Memory and Direct Connection • Enforce mutual exclusion • Exchange information send (destination, message) receive (source, message) 17
Synchronization • Sender and receiver may or may not be blocking (waiting for message) • Blocking send, blocking receive – Both sender and receiver are blocked until message is delivered – Called a rendezvous 18
Synchronization • Nonblocking send, blocking receive – Sender continues on – Receiver is blocked until the requested message arrives • Nonblocking send, nonblocking receive – Neither party is required to wait 19
Addressing • Direct addressing – Send primitive includes a specific identifier of the destination process – Receive primitive could know ahead of time which process a message is expected – Receive primitive could use source parameter to return a value when the receive operation has been performed 20
Direct Addressing • Piped Steams : C and Java – Used to create connections between threads. 21
Addressing • Indirect addressing – Messages are sent to a shared data structure consisting of queues – Queues are called mailboxes – One process sends a message to the mailbox and the other process picks up the message from the mailbox 22
23
Message Format 24
25
26
Mutual Exclusion: Hardware Support • Test and Set Instruction boolean testset (int i) { if (i == 0) { i = 1; return true; } else { return false; } } 27
Mutual Exclusion: Hardware Support • Exchange Instruction void exchange(int register, int memory) { int temp; temp = memory; memory = register; register = temp; } 28
Mutual Exclusion 29
Mutual Exclusion Machine Instructions • Advantages – Applicable to any number of processes on either a single processor or multiple processors sharing main memory – It is simple and therefore easy to verify – It can be used to support multiple critical sections 30
Mutual Exclusion Machine Instructions • Disadvantages – Busy-waiting consumes processor time – Starvation is possible when a process leaves a critical section and more than one process is waiting. – Deadlock • If a low priority process has the critical region and a higher priority process needs, the higher priority process will obtain the processor to wait for the critical region 31
Semaphores • Special variable called a semaphore is used for signaling • If a process is waiting for a signal, it is suspended until that signal is sent 32
Semaphores • Semaphore is a variable that has an integer value – May be initialized to a nonnegative number – Wait operation decrements the semaphore value – Signal operation increments semaphore value 33
34
35
Mutual Exclusion Using Semaphores 36
37
38
Producer/Consumer Problem • One or more producers are generating data and placing these in a buffer • A single consumer is taking items out of the buffer one at time • Only one producer or consumer may access the buffer at any one time 39
Producer producer: while (true) { /* produce item v */ b[in] = v; in++; } 40
Consumer consumer: while (true) { while (in <= out) /*do nothing */; w = b[out]; out++; /* consume item w */ } 41
Producer/Consumer Problem 42
Producer with Circular Buffer producer: while (true) { /* produce item while ((in + 1) /* do nothing b[in] = v; in = (in + 1) % } v */ % n == out) */; n 43
Consumer with Circular Buffer consumer: while (true) { while (in == out) /* do nothing */; w = b[out]; out = (out + 1) % n; /* consume item w */ } 44
45
46
47
48
49
Monitors • Monitor is a software module • Chief characteristics – Local data variables are accessible only by the monitor – Process enters monitor by invoking one of its procedures – Only one process may be executing in the monitor at a time 50
51
52
53
54
Readers/Writers Problem • Any number of readers may simultaneously read the file • Only one writer at a time may write to the file • If a writer is writing to the file, no reader may read it 55
56
57
Concurrency • Multiple applications – Multiprogramming • Structured application – Application can be a set of concurrent processes • Operating-system structure – Operating system is a set of processes or threads 58
Competition Among Processes for Resources • Mutual Exclusion – Critical sections • Only one program at a time is allowed in its critical section • Example only one process at a time is allowed to send command to the printer • Deadlock – Next Chapter • Starvation – Next Chapter 59
60
- Singhal's heuristic algorithm
- Design fifo and non fifo execution
- Mutual exclusion.
- Performance metrics for mutual exclusion algorithm
- Contoh mutual exclusion
- Ricart agrawala second algorithm
- Dijkstra mutual exclusion algorithm
- Mutual exclusion in distributed systems
- Indirect and mutual holdings chapter 9
- Indirect and mutual holdings chapter 9
- Synchronization algorithms and concurrent programming
- Chapter 13 investing in mutual funds
- Concurrency control and recovery
- Apa yang dimaksud dengan recovery
- Ccs milner
- Safety and liveness in concurrency
- Transactions and concurrency control in distributed systems
- Transaction and concurrency control in dbms
- Transactions and concurrency control
- Special segments in triangles worksheet
- Transaction management and concurrency control
- Literature review problem statement
- Narrative review vs systematic review
- What is the inclusion and exclusion criteria in research
- Exclusion crisis in absalom and achitophel
- State pauli's exclusion principle class 11
- Fast clock to slow clock synchronization
- Is a high level synchronization construct
- Process synchronization in os
- Tally data synchronization
- Multiprocessor synchronization
- Lean synchronization
- Simple bgp configuration example
- Lock free synchronization
- Classical problem of synchronization in operating system
- Synchronization tools in os
- Process synchronization in os
- Basic synchronization principles
- Windchill workspace
- Syncthreads
- Process synchronization definition
- Laser synchronization
- Pthread synchronization
- Posix shared memory synchronization
- Synchronization primitives c#
- Process synchronization definition
- Linux kernel synchronization
- Linux
- Clock synchronization in distributed system
- Wait free synchronization
- Which one of the following is a synchronization tool?
- Supply chain synchronization
- Parallel computer architecture cmu
- User123haru
- Classic problems of synchronization
- Process synchronization
- Chia number of threads
- External clock synchronization
- Cs 4414 cornell
- Lamport bakery algorithm in distributed system
- Classical problems of synchronization in os