concurrency: mutual exclusion and synchronization operating systems: internals and design...
TRANSCRIPT
![Page 1: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/1.jpg)
Concurrency: Mutual Exclusion and
Synchronization
Operating Systems:Internals and Design Principles, 6/E
William Stallings
Dave BremerOtago Polytechnic, N.Z.
©2008, Prentice Hall
Dr. Sunny Jeong & M.H. Park
![Page 2: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/2.jpg)
Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
![Page 3: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/3.jpg)
Multiple Processes
• Central to the design of modern Operating Systems is managing multiple processes– Multiprogramming– Multiprocessing– Distributed Processing
• Big Issue is Concurrency – Managing the interaction of all of these
processes
![Page 4: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/4.jpg)
Concurrency
Concurrency arises in:
• Multiple applications– Sharing time
• Structured applications– Extension of modular design
• Operating system structure– OS themselves implemented as a set of
processes or threads
![Page 5: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/5.jpg)
Key Terms
![Page 6: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/6.jpg)
Interleaving and Overlapping Processes
• Earlier (Ch2) we saw that processes may be interleaved on uniprocessors
![Page 7: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/7.jpg)
Interleaving and Overlapping Processes
• And not only interleaved but overlapped on multi-processors
![Page 8: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/8.jpg)
Difficulties of Concurrency
• Sharing of global resources
• Optimally managing the allocation of resources
• Difficult to locate programming errors as results are not deterministic and reproducible.
![Page 9: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/9.jpg)
A Simple Example
void echo()
{
chin = getchar();
chout = chin;
putchar(chout);
}
![Page 10: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/10.jpg)
A Simple Example: On a Multiprocessor
Process P1 Process P2
. .
chin = getchar(); .
. chin = getchar();
chout = chin; chout = chin;
putchar(chout); .
. putchar(chout);
. .
![Page 11: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/11.jpg)
Enforce Single Access
• If we enforce a rule that only one process may enter the function at a time then:
• P1 & P2 run on separate processors
• P1 enters echo first, – P2 tries to enter but is blocked – P2 suspends
• P1 completes execution– P2 resumes and executes echo
![Page 12: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/12.jpg)
Race Condition
• A race condition occurs when – Multiple processes or threads read and write
data items – They do so in a way where the final result
depends on the order of execution of the processes.
• The output depends on who finishes the race last.
![Page 13: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/13.jpg)
Operating System Concerns
• What design and management issues are raised by the existence of concurrency?
• The OS must – Keep track of various processes– Allocate and de-allocate resources– Protect the data and resources against
interference by other processes.– Ensure that the processes and outputs are
independent of the processing speed
![Page 14: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/14.jpg)
Process Interaction
![Page 15: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/15.jpg)
Competition among Processes for Resources
Three main control problems:
• Need for Mutual Exclusion– Critical sections
• Deadlock
• Starvation
![Page 16: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/16.jpg)
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
![Page 17: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/17.jpg)
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
![Page 18: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/18.jpg)
Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
![Page 19: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/19.jpg)
Disabling Interrupts
• Uniprocessors only allow interleaving
• Interrupt Disabling– A process runs until it invokes an operating
system service or until it is interrupted– Disabling interrupts guarantees mutual
exclusion– Will not work in multiprocessor architecture
![Page 20: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/20.jpg)
Pseudo-Code
while (true) {/* disable interrupts */;
/* critical section */;
/* enable interrupts */;
/* remainder */;
}
![Page 21: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/21.jpg)
Special MachineInstructions
• Compare&Swap Instruction – also called a “compare and exchange
instruction”
• Exchange Instruction
![Page 22: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/22.jpg)
Compare&Swap Instruction
int compare_and_swap (int *word,
int testval, int newval)
{int oldval;
oldval = *word;
if (oldval == testval) *word = newval;
return oldval;
}
![Page 23: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/23.jpg)
Mutual Exclusion (fig 5.2)
![Page 24: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/24.jpg)
Exchange instruction
void exchange (int register, int memory)
{int temp;
temp = memory;
memory = register;
register = temp;
}
![Page 25: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/25.jpg)
Exchange Instruction (fig 5.2)
![Page 26: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/26.jpg)
Hardware Mutual Exclusion: 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
![Page 27: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/27.jpg)
Hardware Mutual Exclusion: Disadvantages
• Busy-waiting consumes processor time
• Starvation is possible when a process leaves a critical section and more than one process is waiting. – Some process could indefinitely be denied
access.
• Deadlock is possible
![Page 28: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/28.jpg)
Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
![Page 29: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/29.jpg)
Semaphore• An integer value used for signalling among processes. • Only three operations may be performed on a
semaphore, all of which are atomic: – initialize,
to initialized to a nonnegative integer value– Decrement (semWait)
• If the value becomes (-) the process executing the semWait is blocked. Otherwise, the process continues
– increment. (semSignal)
• If the resulting value is less than or equal to zero, a process blocked by a semWait operaton if any, is unblocked
![Page 30: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/30.jpg)
Semaphore Primitives
![Page 31: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/31.jpg)
Binary Semaphore Primitives
![Page 32: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/32.jpg)
Strong/WeakSemaphore
• A queue is used to hold processes waiting on the semaphore– In what order are processes removed from
the queue?
• Strong Semaphores use FIFO
• Weak Semaphores don’t specify the order of removal from the queue
![Page 33: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/33.jpg)
Example of Strong Semaphore Mechanism
(Process a, b, c depend on d’s result)
![Page 34: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/34.jpg)
Example of Semaphore Mechanism
![Page 35: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/35.jpg)
Mutual Exclusion Using Semaphores
![Page 36: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/36.jpg)
Mutual Exclusion Using Semaphores
Consider n processes, identified in the array P(i), all of which need access to the same resource s. – Each process has a critical section used to access
the resource. – In each process, a semWait(s) is executed just
before its critical section. • If the value of s becomes negative, the process is blocked. • If the value is 1, then it is decremented to 0 and the process
immediately enters its critical section;
– because s is no longer positive, no other process will be able to enter its critical section.
![Page 37: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/37.jpg)
Processes Using Semaphore
![Page 38: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/38.jpg)
Producer/Consumer Problem
• General Situation:– 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
• The Problem:– Ensure that the Producer can’t add data into full buffer
and consumer can’t remove data from empty buffer
![Page 39: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/39.jpg)
Functions
Producer Consumer
while (true) {/* produce item v */b[in] = v;in++; }
while (true) { while (in <= out) /*do nothing */;w = b[out];out++; /* consume item w */}
• Assume an infinite buffer b with a linear array of elements
![Page 40: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/40.jpg)
Buffer
![Page 41: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/41.jpg)
Incorrect Solution
![Page 42: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/42.jpg)
Possible Scenario
![Page 43: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/43.jpg)
Correct Solution
![Page 44: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/44.jpg)
Semaphores
![Page 45: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/45.jpg)
Bounded Buffer
![Page 46: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/46.jpg)
Bounded-buffer (solution using general semaphore)
![Page 47: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/47.jpg)
Functions in a Bounded Buffer
Producer Consumer
while (true) {/* produce item v */while ((in + 1) % n == out) /* do nothing */;b[in] = v;in = (in + 1) % n}
while (true) {while (in == out)
/* do nothing */;
w = b[out];out = (out + 1) %
n;/* consume item w
*/}
• .
![Page 48: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/48.jpg)
Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
![Page 49: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/49.jpg)
Monitors
• The monitor is a programming-language construct that provides equivalent functionality to that of semaphores and that is easier to control.
• Implemented in a number of programming languages, including – Concurrent Pascal, Pascal-Plus,– Modula-2, Modula-3, and Java.
![Page 50: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/50.jpg)
Chief characteristics
(A monitor is a software module consisting of one or more procedures and initialization sequence, and local data.)
• 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
![Page 51: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/51.jpg)
Synchronization
• Synchronisation achieved by condition variables within a monitor – only accessible by the monitor.
• Monitor Functions:
–Cwait(c): Suspend execution of the calling process on condition c
–Csignal(c) Resume execution of some process blocked after a cwait on the same condition
![Page 52: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/52.jpg)
Structure of a Monitor
![Page 53: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/53.jpg)
Bounded Buffer Solution Using Monitor
![Page 54: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/54.jpg)
Solution Using Monitor
![Page 55: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/55.jpg)
Bounded Buffer Monitor
![Page 56: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/56.jpg)
Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
![Page 57: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/57.jpg)
Process Interaction
• When processes interact with one another, two fundamental requirements must be satisfied: – synchronization and – communication.
• Message Passing is one solution to the second requirement– Added bonus: It works with shared memory
and with distributed systems
![Page 58: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/58.jpg)
Message Passing
• The actual function of message passing is normally provided in the form of a pair of primitives:
• send (destination, message)
• receive (source, message)
![Page 59: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/59.jpg)
Synchronization
• Communication requires synchronization
• What happens to a process after it issues a send or receive primitive?– Need to specify what happens to a process
after a communication issues a send or receive primitive
– Sender and receiver may or may not be blocking (waiting for message)
![Page 60: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/60.jpg)
Blocking send, Blocking receive
• Both sender and receiver are blocked until message is delivered
• Known as a rendezvous
• Allows for tight synchronization between processes.
![Page 61: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/61.jpg)
Non-blocking Send
• More natural for many concurrent programming tasks.
• 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
![Page 62: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/62.jpg)
Addressing
• Sending process need to be able to specify which process should receive the message– Direct addressing– Indirect Addressing
![Page 63: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/63.jpg)
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
![Page 64: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/64.jpg)
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
![Page 65: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/65.jpg)
Indirect Process Communication
![Page 66: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/66.jpg)
General Message Format
![Page 67: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/67.jpg)
Mutual Exclusion Using Messages
Assume the use of the blocking receive primitive and the non-blocking send primitive.
This assumes that if more than one process performs the receive operation concurrently, then
• If there is a message, it is delivered to only one process and the others are blocked, or• If the message queue is empty, all processes are blocked; when a message is available, only one blocked process is activated and given the message.
![Page 68: Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Dave Bremer Otago Polytechnic,](https://reader035.vdocuments.site/reader035/viewer/2022081508/56649ea35503460f94ba8244/html5/thumbnails/68.jpg)
Producer/Consumer Messages
Takes advantage of the ability of message passing to be used to pass data in addition to signals.
Two mailboxes are used. As the producer generates data, it is sent as messages to the mailbox mayconsume. As long as there is at least one message in that mailbox, the consumer can consume.
Hence mayconsume serves as the buffer; the data in the buffer are organized as a queue of messages.