and examples) synchronization (tools chapter 6 and 7jamik/dm510-19/material/lecture-04.pdf ·...
TRANSCRIPT
![Page 1: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/1.jpg)
CHAPTER 6 AND 7 -CHAPTER 6 AND 7 -SYNCHRONIZATION (TOOLSSYNCHRONIZATION (TOOLS
AND EXAMPLES)AND EXAMPLES)1
![Page 2: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/2.jpg)
INTRODUCTIONINTRODUCTIONA cooperating process can affect or be affected by other processes
executing.
share a logical address space (code and data)
share data through shared memory or messagepassing
Concurrent access to shared data may result in datainconsistency
2
![Page 3: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/3.jpg)
OBJECTIVESOBJECTIVESIntroduce the critical-section problem → solutions used to ensureconsistency of shared data.
software and hardware solutions of the critical-section problem.
examine classical process-synchronization problems.
explore several tools that are used to solve processsynchronization problems.
3
![Page 4: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/4.jpg)
BACKGROUNDBACKGROUND
4 . 1
![Page 5: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/5.jpg)
BACKGROUNDBACKGROUNDProcesses can execute concurrently
May be interrupted at any time, partially completingexecution
Concurrent access to shared data may result in data inconsistency
Maintaining data consistency requires mechanisms to ensure theorderly execution of cooperating processes
4 . 2
![Page 6: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/6.jpg)
THE PROBLEMTHE PROBLEMWant to provide a solution to the consumer-producer problemthat �lls all the buffers.
Have integer counter that keeps track of the number of full buffers.
Initially, counter is set to 0.
incremented by the producer after it produces a newbuffer
decremented by the consumer after it consumes a buffer.
4 . 3
![Page 7: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/7.jpg)
PRODUCERPRODUCERwhile (true) { /* produce an item in next produced */ while (counter == BUFFER_SIZE) { /* do nothing */ } buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; counter++; }
4 . 4
![Page 8: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/8.jpg)
CONSUMERCONSUMERwhile (true) { while (counter == 0){ /* do nothing */ } next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; counter--; /* consume the item in next consumed */ }
4 . 5
![Page 9: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/9.jpg)
CONSUMER-PRODUCER PROBLEMCONSUMER-PRODUCER PROBLEMWorks well separately!
May not work correctly when executed concurrently
4 . 6
![Page 10: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/10.jpg)
IMPLEMENTATIONIMPLEMENTATIONcounter++ could be implementedas
counter-- could be implementedas
register1 = counter register1 = register1 + 1 counter = register1
register2 = counter register2 = register2 - 1 counter = register2
4 . 7
![Page 11: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/11.jpg)
INITIALLY COUNTER=5INITIALLY COUNTER=5T0 register1 = counter register1 = 5
T1 register1 = register1 + 1 register1 = 6
T2 register2 = counter register2 = 5
T3 register2 = register2 – 1 register2 = 4
T4 counter = register1 counter = 6
T5 counter = register2 counter = 4
4 . 8
![Page 12: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/12.jpg)
RACE CONDITIONRACE CONDITIONA Race Condition is where several processes access and manipulate
the same data concurrently and the outcome of the executiondepends on the particular order in which the access takes place.
Need some synchronization to solve this
4 . 9
![Page 13: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/13.jpg)
THE CRITICAL-SECTION PROBLEMTHE CRITICAL-SECTION PROBLEM
5 . 1
![Page 14: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/14.jpg)
CRITICAL SECTION PROBLEMCRITICAL SECTION PROBLEMConsider system of n processes {p0, p1, … pn-1 }
Each process has critical section segment of code
Process may be changing common variables, updating table,writing �le, etc
When one process in critical section, no other may be in its criticalsection
Th critical section problem is to design protocol to solve this
5 . 2
![Page 15: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/15.jpg)
CRITICAL SECTIONCRITICAL SECTIONGeneral structure of process pi is
5 . 3
![Page 16: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/16.jpg)
SOLUTION TO CRITICAL SECTION PROBLEMSOLUTION TO CRITICAL SECTION PROBLEMA solution must satisfy 3 requirements
Mutual Exclusion
Progress
BoundedWaiting
5 . 4
![Page 17: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/17.jpg)
MUTUAL EXCLUSIONMUTUAL EXCLUSIONIf process Pi is executing in its critical section, then no other
processes can be executing in their critical sections
5 . 5
![Page 18: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/18.jpg)
PROGRESSPROGRESSIf no process is executing in its critical section and there exist some
processes that wish to enter their critical section, then the selectionof the processes that will enter the critical section next cannot be
postponed inde�nitely
5 . 6
![Page 19: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/19.jpg)
BOUNDED WAITINGBOUNDED WAITINGA bound must exist on the number of times that other processes are
allowed to enter their critical sections after a process has made arequest 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 nprocesses
5 . 7
![Page 20: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/20.jpg)
KERNEL MODE EXAMPLEKERNEL MODE EXAMPLE
5 . 8
![Page 21: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/21.jpg)
TWO APPROACHESTWO APPROACHESTwo approaches depending on if kernel is preemptive or non-
preemptive
Preemptive – allows preemption of process when running inkernel mode
Non-preemptive – runs until exits kernel mode, blocks, orvoluntarily yields CPU
Essentially free of race conditions in kernel mode
5 . 9
![Page 22: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/22.jpg)
PETERSON’S SOLUTIONPETERSON’S SOLUTIONA classic software-based solution to the critical-section
6 . 1
![Page 23: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/23.jpg)
PETERSON’S SOLUTIONPETERSON’S SOLUTIONGood algorithmic description of solving the problem
Two process solution
Assume that the load and store instructions are atomic; that is,cannot be interrupted
6 . 2
![Page 24: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/24.jpg)
PETERSON’S SOLUTIONPETERSON’S SOLUTIONThe two processes share two variables:
The variable turn indicates whose turn it is to enter the criticalsection
The �ag array is used to indicate if a process is ready to enter thecritical section. flag[i] = true implies that process Pi is ready!
int turn;
Boolean flag[2]
6 . 3
![Page 25: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/25.jpg)
ALGORITHM FOR PROCESS PALGORITHM FOR PROCESS PII
Provable that 1), 2) and 3) holds
while (true) { flag[i] = true; turn = j; while (flag[j] && turn == j) ; /* critical section */ flag[i] = false; /*remainder section */ }
6 . 4
![Page 26: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/26.jpg)
PETERSONS SOLUTION ON MODERN ARCHITECTUREPETERSONS SOLUTION ON MODERN ARCHITECTUREModern Architechtures: To improve system performance, processorsand/or compilers may reorder read and write operations that have no
dependencies
For a multithreaded application with shared data, the reordering ofinstructions may render inconsistent or unexpected results.
6 . 5
![Page 27: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/27.jpg)
MODERN ARCHITECTUREMODERN ARCHITECTUREShared between two threads
Thread 1
Thread 2
boolean flag = false; int x = 0;
while (!flag) ; print x;
x = 100; flag = true;
6 . 6
![Page 28: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/28.jpg)
PETERSONS SOLUTION ON MODERN ARCHITECTUREPETERSONS SOLUTION ON MODERN ARCHITECTURE
6 . 7
![Page 29: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/29.jpg)
HARDWARE SUPPORT FOR SYNCHRONIZATIONHARDWARE SUPPORT FOR SYNCHRONIZATION
7 . 1
![Page 30: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/30.jpg)
MEMORY BARRIERSMEMORY BARRIERSComputer architecture memory guarantees it will provide to an
application program:
1. Strongly ordered: Memory modi�cation on one processor isimmediately visible to all other processors.
2. Weakly ordered:, Modi�cations to memory on one processor maynot be immediately visible to other processors.
Vary by processor type
7 . 2
![Page 31: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/31.jpg)
MEMORY BARRIERSMEMORY BARRIERSComputer architectures provide instructions that can force anychanges in memory to be propagated to all other processors ⇒
ensuring that memory modi�cations are visible to threads running onother processors. Such instructions are known as memory barriers
or memory fences.
System ensures that all loads and stores are completed before anysubsequent load or store operations are performed.
7 . 3
![Page 32: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/32.jpg)
MEMORY BARRIERSMEMORY BARRIERSThread 1
Thread 2
while (!flag) ; memory_barrier(); print x;
x = 100; memory_barrier(); flag = true;
7 . 4
![Page 33: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/33.jpg)
HARDWARE INSTRUCTIONSHARDWARE INSTRUCTIONSModern machines provide special atomic hardware instructions
Atomic = non-interruptible
Either test memory word and set value: test_and_set()
Or swap contents of two memory words:compare_and_swap()
7 . 5
![Page 34: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/34.jpg)
TEST AND SET INSTRUCTIONTEST AND SET INSTRUCTIONDe�nition
boolean test_and_set(boolean *target) { boolean read_value = *target; *target = true; return read_value; }
7 . 6
![Page 35: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/35.jpg)
SOLUTION USING TEST AND SETSOLUTION USING TEST AND SETShared boolean variable lock, initialized to FALSE
do { while( test_and_set(&lock) ) { ; /* DO NOTHING */ } /* Chritical section */ lock = false; /* remainder section */ } while(true);
7 . 7
![Page 36: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/36.jpg)
COMPARE AND SWAP INSTRUCTIONCOMPARE AND SWAP INSTRUCTIONDe�nition
int compare_and_swap(int *value, int expected, int new_value) { int temp = *value; if( *value == expected) { *value = new_value; } return temp; }
7 . 8
![Page 37: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/37.jpg)
SOLUTION USING COMPARE_AND_SWAPSOLUTION USING COMPARE_AND_SWAPShared Boolean variable lock initialized to FALSE; Each process has a
local Boolean variable keydo { while( compare_and_swap(&lock, 0, 1) != 0 ) { ; /* DO NOTHING */ } /* Chritical section */ lock = 0; /* remainder section */ } while(true);
7 . 9
![Page 38: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/38.jpg)
BOUNDED-WAITING MUTUAL EXCLUSION WITH TESTBOUNDED-WAITING MUTUAL EXCLUSION WITH TESTAND SETAND SET
do { waiting[i] = true; key = true; while (waiting[i] && key) key = test and set(&lock); waiting[i] = false; /* critical section */ j = (i + 1) % n; while ((j != i) && !waiting[j]) j = (j + 1) % n; if (j == i) lock = false; else waiting[j] = false; /* remainder section */ } while (true);
7 . 10
![Page 39: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/39.jpg)
ATOMIC VARIABLESATOMIC VARIABLESTypically, the compare_and_swap() instruction is not used directly
to provide mutual exclusion.
It is used as a basic building block for constructing other tools thatsolve the critical-section problem.
One such tool is an atomic variable, which provides atomicoperations on basic data types such as integers and booleans.
7 . 11
![Page 40: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/40.jpg)
ATOMIC VARIABLESATOMIC VARIABLESFor atomic integer sequence
Can be implemented like
increment(&sequence);
void increment(atomic_int *v) { int temp; do { temp = *v; } while (temp != compare_and_swap(v, temp, temp+1)); }
7 . 12
![Page 41: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/41.jpg)
MUTEX LOCKSMUTEX LOCKS
8 . 1
![Page 42: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/42.jpg)
MUTEX LOCKSMUTEX LOCKSPrevious solutions are complicated and generally inaccessible to
application programmers
OS designers build software tools to solve critical section problem
Simplest is mutex lock
Product critical regions with it by �rst acquire() a lock thenrelease() it
8 . 2
![Page 43: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/43.jpg)
SOLUTION TO THE CRITICAL-SECTION PROBLEM USINGSOLUTION TO THE CRITICAL-SECTION PROBLEM USINGMUTEX LOCKSMUTEX LOCKS
while (true) { // acquire lock // critical section // release lock // remainder section }
8 . 3
![Page 44: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/44.jpg)
MUTEX LOCKSMUTEX LOCKSCalls to acquire() and release() must be atomic
Boolean variable indicating if lock is available or not → Usuallyimplemented via hardware atomic instructions
But this solution requires busy waiting → This lock therefore called aspinlock
8 . 4
![Page 45: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/45.jpg)
ACQUIRE()ACQUIRE()acquire() { while (!available) { ; /* busy wait */ } available = false;; }
8 . 5
![Page 46: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/46.jpg)
RELEASE()RELEASE()release() { available = true; }
8 . 6
![Page 47: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/47.jpg)
SEMAPHORESSEMAPHORES
9 . 1
![Page 48: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/48.jpg)
SEMAPHORESEMAPHORESynchronization tool that does not require busy waiting
Semaphore S – integer variable
Two standard operations modify S
Originally called P() and V()
wait()
signal()
9 . 2
![Page 49: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/49.jpg)
SEMAPHORESEMAPHORECan only be accessed via two indivisible (atomic) operations
wait (S) { while (S <= 0) { ; // busy wait } S--; }
signal (S) { S++; }
9 . 3
![Page 50: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/50.jpg)
SEMAPHORE USAGESEMAPHORE USAGECounting semaphore – integer value can range over anunrestricted domain
Binary semaphore – integer value can range only between 0 and 1
Then a mutex lock
Can implement a counting semaphore S as a binary semaphore
Can solve various synchronization problems
9 . 4
![Page 51: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/51.jpg)
SEMAPHORE USAGESEMAPHORE USAGEConsider P1 and P2 that require S1 to happen before S2
P1:
S1;
signal(synch);
P2:
wait(synch);
S2;
9 . 5
![Page 52: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/52.jpg)
SEMAPHORE IMPLEMENTATIONSEMAPHORE IMPLEMENTATIONMust 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 wherethe wait and signal code are placed in the critical section
9 . 6
![Page 53: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/53.jpg)
SEMAPHORE IMPLEMENTATIONSEMAPHORE IMPLEMENTATIONCould now have busy waiting in critical sectionimplementation
But implementation code is short
Little busy waiting if critical section rarely occupied
9 . 7
![Page 54: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/54.jpg)
SEMAPHORE IMPLEMENTATION - NO BUSY WAITINGSEMAPHORE IMPLEMENTATION - NO BUSY WAITINGWith 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 thelist
9 . 8
![Page 55: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/55.jpg)
SEMAPHORE IMPLEMENTATION - NO BUSY WAITINGSEMAPHORE IMPLEMENTATION - NO BUSY WAITINGTwo operations:
sleep – place the process invoking the operation on theappropriate waiting queue
wakeup – remove one of processes in the waiting queue and placeit in the ready queue
OS provides those as basic system calls
9 . 9
![Page 56: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/56.jpg)
SEMAPHORE IMPLEMENTATION - NO BUSY WAITINGSEMAPHORE IMPLEMENTATION - NO BUSY WAITINGtypedef struct{ int value; struct process *list; } semaphore;
9 . 10
![Page 57: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/57.jpg)
SEMAPHORE IMPLEMENTATION - NO BUSY WAITINGSEMAPHORE IMPLEMENTATION - NO BUSY WAITINGwait(semaphore *S) { S->value--; if (S->value < 0) { add this process to S->list; sleep(); } }
9 . 11
![Page 58: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/58.jpg)
SEMAPHORE IMPLEMENTATION - NO BUSY WAITINGSEMAPHORE IMPLEMENTATION - NO BUSY WAITINGsignal(semaphore *S) { S->value++; if (S->value <= 0) { remove a process P from S->list; wakeup(P); } }
9 . 12
![Page 59: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/59.jpg)
MONITORSMONITORS
10 . 1
![Page 60: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/60.jpg)
PROBLEMS WITH SEMAPHORESPROBLEMS WITH SEMAPHORESIncorrect use of semaphore operations:
signal(mutex) … . wait(mutex)
wait(mutex) … wait(mutex)
Omitting of wait(mutex) or signal(mutex) (orboth)
Deadlock and starvation
10 . 2
![Page 61: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/61.jpg)
MONITORSMONITORSA high-level abstraction that provides a convenient and effective
mechanism for process synchronization
Abstract data type, internal variables only accessible by code withinthe procedure
Only one process may be active within the monitor at a time
10 . 3
![Page 62: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/62.jpg)
MONITORSMONITORSmonitor monitor name { /* shared variable declarations */ function P1 ( . . . ) { . . . } function P2 ( . . . ) { . . . } . . . function Pn ( . . . ) { . . . } initialization_code ( . . . ) { . . . } }
10 . 4
![Page 63: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/63.jpg)
SCHEMATIC VIEW OF A MONITORSCHEMATIC VIEW OF A MONITOR
10 . 5
![Page 64: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/64.jpg)
MONITORSMONITORSNot powerful enough to model some synchronization schemes
To be more powerfull → condition construct
10 . 6
![Page 65: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/65.jpg)
CONDITION VARIABLESCONDITION VARIABLES
Two operations on a condition variable:
x.wait() – a process that invokes the operation is suspendeduntil x.signal()
x.signal() – resumes one of processes (if any) that invokedx.wait()
If no x.wait() on the variable, then it has no effect on thevariable
condition x, y;
10 . 7
![Page 66: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/66.jpg)
MONITOR WITH CONDITION VARIABLESMONITOR WITH CONDITION VARIABLES
10 . 8
![Page 67: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/67.jpg)
CONDITION VARIABLES CHOICESCONDITION VARIABLES CHOICESIf process P invokes x.signal(), with Q in x.wait() state, whatshould happen next?
If Q is resumed, then P must wait
Options include
Signal and wait – P waits until Q leaves monitor or waits foranother condition
Signal and continue – Q waits until P leaves the monitor or waitsfor another condition
10 . 9
![Page 68: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/68.jpg)
CONDITION VARIABLES CHOICESCONDITION VARIABLES CHOICESBoth have pros and cons – language implementer can decide
Monitors implemented in Concurrent Pascal compromise → Pexecuting signal immediately leaves the monitor, Q is resumed
Implemented in other languages including Mesa, C#, Java
10 . 10
![Page 69: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/69.jpg)
MONITOR IMPLEMENTATION USING SEMAPHORESMONITOR IMPLEMENTATION USING SEMAPHORESsemaphore mutex; // (initially = 1)
semaphore next; // (initially = 0)
int next_count = 0;
10 . 11
![Page 70: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/70.jpg)
MONITOR IMPLEMENTATION USING SEMAPHORESMONITOR IMPLEMENTATION USING SEMAPHORESEach procedure F will be replaced by
Mutual exclusion within a monitor is ensured
wait(mutex);
...
body of F;
...
if (next_count > 0) {
signal(next)
} else {
signal(mutex);
}
10 . 12
![Page 71: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/71.jpg)
MONITOR IMPLEMENTATION – CONDITION VARIABLESMONITOR IMPLEMENTATION – CONDITION VARIABLESFor each condition variable x, we have:
semaphore x_sem; // (initially = 0)
int x_count = 0;
10 . 13
![Page 72: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/72.jpg)
MONITOR IMPLEMENTATION – CONDITION VARIABLESMONITOR IMPLEMENTATION – CONDITION VARIABLESThe operation x.wait can be implemented as:
x_count++;
if (next_count > 0) {
signal(next);
} else {
signal(mutex);
}
wait(x_sem);
x_count--;
10 . 14
![Page 73: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/73.jpg)
MONITOR IMPLEMENTATION – CONDITION VARIABLESMONITOR IMPLEMENTATION – CONDITION VARIABLESThe operation x.signal can be implemented as:
if (x_count > 0) {
next_count++;
signal(x_sem);
wait(next);
next_count--;
}
10 . 15
![Page 74: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/74.jpg)
RESUMING PROCESSES WITHIN A MONITORRESUMING PROCESSES WITHIN A MONITORIf several processes queued on condition x, and x.signal()
executed, which should be resumed?
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 schedulednext
10 . 16
![Page 75: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/75.jpg)
A MONITOR TO ALLOCATE SINGLE RESOURCEA MONITOR TO ALLOCATE SINGLE RESOURCEmonitor ResourceAllocator { boolean busy; condition x; void acquire(int time) { if (busy) x.wait(time); busy = true; } void release() { busy = false; x.signal(); } initialization code() { busy = false; } }
10 . 17
![Page 76: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/76.jpg)
MONITOR SHORTCOMMINGSMONITOR SHORTCOMMINGSMonitor concept cannot guarantee that the preceding access
sequence will be observed
A process might access a resource without �rst gaining accesspermission to the resource.
A process might never release a resource once it has been grantedaccess to the resource.
A process might attempt to release a resource that it neverrequested.
A process might request the same resource twice (without �rstreleasing the resource).
10 . 18
![Page 77: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/77.jpg)
LIVENESSLIVENESSLiveness refers to a set of properties that a system must satisfy to
ensure that processes make progress during their execution lifecycle.
A process waiting inde�nitely under the circumstances just describedis an example of a "liveness failure."
11 . 1
![Page 78: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/78.jpg)
DEADLOCKDEADLOCKDeadlock – two or more processes are waiting inde�nitely for an
event that can be caused by only one of the waiting processes
11 . 2
![Page 79: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/79.jpg)
DEADLOCKDEADLOCKLet S and Q be two semaphores initialized to 1
P0 P1
wait(S); wait(Q);
wait(Q); wait(S);
... ...
signal(S); signal(Q);
signal(Q); signal(S);
11 . 3
![Page 80: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/80.jpg)
PRIORITY INVERSIONPRIORITY INVERSIONAssume 3 processes with priority L < M < H
Resource R is being held by L
Proces H require resource R, waits for L
Proces M becomes runnable, preempting L
Result: M affects how long process H must wait forL
Let processes borrow higher priority while waiting forresources
11 . 4
![Page 81: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/81.jpg)
PRIORITY INVERSIONPRIORITY INVERSIONPriority Inversion – Scheduling problem when lower-priority process
holds a lock needed by higher-priority process
Solved via priority-inheritance protocol
11 . 5
![Page 82: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/82.jpg)
EVALUATIONEVALUATIONWhen should which tool be used?
12 . 1
![Page 83: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/83.jpg)
LOW LEVEL TOOLSLOW LEVEL TOOLSLow level
test and set
compare and swap(CAS)
Typically used to implement other tools
CAS-based approaches are considered an optimistic approach—youoptimistically �rst update a variable and then use collision detection
to see if another thread is updating the variable concurrently.
12 . 2
![Page 84: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/84.jpg)
CAS-BASED OR TRADITIONAL SYNC.CAS-BASED OR TRADITIONAL SYNC.Uncontended: Both options are generally fast, CAS protection willbe somewhat faster than traditional synchronization.
Moderate contention: CAS protection will be faster—possiblymuch faster—than traditional synchronization.
High contention: Under very highly contended loads, traditionalsynchronization will ultimately be faster than CAS-basedsynchronization.
12 . 3
![Page 85: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/85.jpg)
MODERATE CONTENTIONMODERATE CONTENTIONCAS operation succeeds most of the time, and when it fails, it will
iterate through the loop a feww times
Mutual-exclusion locking, any attempt to acquire a contended lockwill result in a more complicated—and time-intensive—code paththat suspends a thread and places it on a wait queue, requiring a
context switch to another thread.
12 . 4
![Page 86: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/86.jpg)
RULES OF THUMBRULES OF THUMBAtomic integers are much lighter weight than traditional locks
Spinlocks are used on multiprocessor systems when locks are heldfor short durations
Controlling access to a �nite number of resources—a countingsemaphore is generally more appropriate than a mutex lock
12 . 5
![Page 87: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/87.jpg)
ONGOING RESEARCHONGOING RESEARCHDesigning compilers that generate more ef�cient code.
Developing languages that provide support for concurrentprogramming.
Improving the performance of existing libraries and APIs.
12 . 6
![Page 88: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/88.jpg)
CLASSIC PROBLEMS OF SYNCHRONIZATIONCLASSIC PROBLEMS OF SYNCHRONIZATION
13 . 1
![Page 89: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/89.jpg)
CLASSIC PROBLEMS OF SYNCHRONIZATIONCLASSIC PROBLEMS OF SYNCHRONIZATIONClassical problems used to test newly-proposed synchronization
schemes
Bounded-Buffer Problem
Readers and WritersProblem
Dining-Philosophers Problem
13 . 2
![Page 90: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/90.jpg)
BOUNDED-BUFFER PROBLEMBOUNDED-BUFFER PROBLEMint n; semaphore mutex = 1; semaphore empty = n; semaphore full = 0;
13 . 3
![Page 91: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/91.jpg)
PRODUCER PROCESSPRODUCER PROCESSdo { . . . /* produce an item in next produced */ . . . wait(empty); wait(mutex); . . . /* add next produced to the buffer */ . . . signal(mutex); signal(full); } while (true);
13 . 4
![Page 92: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/92.jpg)
CONSUMER PROCESSCONSUMER PROCESSdo { wait(full); wait(mutex); . . . /* remove an item from buffer to next consumed */ . . . signal(mutex); signal(empty); . . . /* consume the item in next consumed */ . . . } while (true);
13 . 5
![Page 93: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/93.jpg)
READERS-WRITERS PROBLEMREADERS-WRITERS PROBLEMA data set is shared among a number of concurrent processes
Readers – only read the data set; they do not perform anyupdates
Writers – can both read and write
13 . 6
![Page 94: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/94.jpg)
READERS-WRITERS PROBLEMREADERS-WRITERS PROBLEMProblem – allow multiple readers to read at the same time
Only one single writer can access the shared data at the sametime
Several variations of how readers and writers are treated
all involve priorities
13 . 7
![Page 95: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/95.jpg)
READERS-WRITERS PROBLEMREADERS-WRITERS PROBLEMShared Data
Dataset
andint read_count = 0; semaphore rw_mutex = 1; semaphore mutex = 1;
13 . 8
![Page 96: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/96.jpg)
WRITERS PROCESSWRITERS PROCESSdo { wait(rw_mutex); . . . /* writing is performed */ . . . signal(rw_mutex); } while (true);
13 . 9
![Page 97: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/97.jpg)
READER PROCESSREADER PROCESSdo { 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);
13 . 10
![Page 98: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/98.jpg)
PROBLEM VARIATIONSPROBLEM VARIATIONSFirst variation – no reader kept waiting unless writer haspermission to use shared object
Second variation – once writer is ready, it performs write asap
Both may have starvation leading to even more variations
Problem is solved on some systems by kernel providing reader-writer locks
13 . 11
![Page 99: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/99.jpg)
USEFULL WHENUSEFULL WHENIn applications where it is easy to identify which processes onlyread shared data and which processes only write shared data.
In applications that have more readers than writers.
13 . 12
![Page 100: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/100.jpg)
DINING-PHILOSOPHERS PROBLEMDINING-PHILOSOPHERS PROBLEM
13 . 13
![Page 101: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/101.jpg)
DINING-PHILOSOPHERS PROBLEMDINING-PHILOSOPHERS PROBLEMPhilosophers spend their lives thinking and eating
Don’t interact with their neighbors, occasionally try to pick up 2chopsticks (one at a time) to eat from bowl
Need both to eat, then release both when done
13 . 14
![Page 102: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/102.jpg)
DINING-PHILOSOPHERS PROBLEMDINING-PHILOSOPHERS PROBLEMShared data
Bowl of rice (data set)
Semaphore chopstick[5] initialized to1
13 . 15
![Page 103: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/103.jpg)
DINING-PHILOSOPHERS PROBLEMDINING-PHILOSOPHERS PROBLEMdo { wait(chopstick[i]); wait(chopstick[(i+1) % 5]); . . . /* eat for awhile */ . . . signal(chopstick[i]); signal(chopstick[(i+1) % 5]); . . . /* think for awhile */ . . . } while (true);
13 . 16
![Page 104: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/104.jpg)
MONITOR TO DINING PHILOSOPHERSMONITOR TO DINING PHILOSOPHERSmonitor 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((i + 4) % 5); test((i + 1) % 5); } ....
13 . 17
![Page 105: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/105.jpg)
SOLUTION TO DINING PHILOSOPHERSSOLUTION TO DINING PHILOSOPHERS ... 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; } }
13 . 18
![Page 106: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/106.jpg)
SOLUTION TO DINING PHILOSOPHERSSOLUTION TO DINING PHILOSOPHERSEach philosopher i invokes the operations pickup() and
putdown() in the following sequence:
No deadlock, but starvation is possible
DiningPhilosophers.pickup(i);
EAT
DiningPhilosophers.putdown(i);
13 . 19
![Page 107: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/107.jpg)
SYNCHRONIZATION WITHIN THE KERNELSYNCHRONIZATION WITHIN THE KERNEL
14 . 1
![Page 108: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/108.jpg)
SYNCHRONIZATION IN WINDOWSSYNCHRONIZATION IN WINDOWSUses interrupt masks to protect access to global resources onsingle-processor systems
Uses spinlocks on multiprocessor systems
Spinlocking-thread will never be preempted
Also provides dispatcher objects in user-land which may actmutexes, semaphores, events, and timers
14 . 2
![Page 109: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/109.jpg)
DISPATCHER OBJECTSDISPATCHER OBJECTSUsing a dispatcher object, threads synchronize according to severaldifferent mechanisms, including mutex locks, semaphores, events,
and timers.
Events: An event acts much like a condition variable
Timers notify one or more thread when time expired
Dispatcher objects either signaled-state (object available) or non-signaled state (thread will block)
14 . 3
![Page 110: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/110.jpg)
LINUX SYNCHRONIZATIONLINUX SYNCHRONIZATIONPrior to kernel Version 2.6, disables interrupts to implement shortcritical sections
Version 2.6 and later, fully preemptive
Linux provides:
atomic integer (atomic_t)
semaphores
spinlocks
reader-writer versions of both
14 . 4
![Page 111: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/111.jpg)
LINUX SYNCHRONIZATIONLINUX SYNCHRONIZATIONOn single-cpu system, spinlocks replaced by enabling and disablingkernel preemption
When a lock must be held for a longer period, semaphores or mutexlocks are appropriate for use.
14 . 5
![Page 112: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/112.jpg)
POSIX SYNCHRONIZATIONPOSIX SYNCHRONIZATION
15 . 1
![Page 113: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/113.jpg)
PTHREADS SYNCHRONIZATIONPTHREADS SYNCHRONIZATIONPthreads API is OS-independent
It provides:
mutex locks
condition variables
Non-portable extensionsinclude:
read-write locks
spinlocks
15 . 2
![Page 114: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/114.jpg)
PTHREADS SYNCHRONIZATIONPTHREADS SYNCHRONIZATION#include <pthread.h> pthread_mutex_t mutex; /* create and initialize the mutex lock */ pthread_mutex_init(&mutex,NULL); /* acquire the mutex lock */ pthread_mutex_lock(&mutex); /* critical section */ /* release the mutex lock */ pthread_mutex_unlock(&mutex);
15 . 3
![Page 115: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/115.jpg)
POSIX NAMED SEMAPHORESPOSIX NAMED SEMAPHORESThe function sem_open() is used to create and open a POSIX
named sempahore:#include <semaphore.h> sem_t *sem; /* Create the semaphore and initialize it to 1 */ sem = sem_open(“SEM”, O_CREAT, 0666, 1); /* acquire the semaphore */ sem_wait(sem); /* critical section */ /* release the semaphore */ sem_post(sem);
15 . 4
![Page 116: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/116.jpg)
POSIX UNNAMED SEMAPHORESPOSIX UNNAMED SEMAPHORESAn unnamed semaphore is created and initialized using the sem_init()
function, which is passed three parameters:
1. A pointer to the semaphore
2. A �ag indicating the level ofsharing
3. The semaphore’s initial value
15 . 5
![Page 117: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/117.jpg)
POSIX UNNAMED SEMAPHORESPOSIX UNNAMED SEMAPHORES#include <semaphore.h> sem_t sem; /* Create the semaphore and initialize it to 1 */ sem_init(&sem, 0, 1); /* acquire the semaphore */ sem_wait(&sem); /* critical section */ /* release the semaphore */ sem_post(&sem);
15 . 6
![Page 118: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/118.jpg)
SYNCHRONIZATION IN JAVASYNCHRONIZATION IN JAVA
16 . 1
![Page 119: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/119.jpg)
LOCKSLOCKSEvery object in Java has associated with it a single lock.
When a method is declared to be synchronized, calling the methodrequires owning the lock for the object. We declare a synchronized
method by placing the synchronized keyword in the methodde�nition
16 . 2
![Page 120: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/120.jpg)
ENTRY AND WAIT SETSENTRY AND WAIT SETS
16 . 3
![Page 121: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/121.jpg)
JAVA MONITORSJAVA MONITORSpublic class BoundedBuffer<E> { private static final int BUFFER_SIZE = 5; private int count, in, out; private E[] buffer; public BoundedBuffer() { count = 0; in = 0; out = 0; buffer = (E[]) new Object[BUFFER_SIZE]; } /* Producers call this method */ public synchronized void insert(E item) { /* See Next slide */ } /* Consumers call this method */ public synchronized E remove() { /* See Figure 7.11 */ } }
16 . 4
![Page 122: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/122.jpg)
JAVA MONITORSJAVA MONITORS/* Producers call this method */ public synchronized void insert(E item) { while (count == BUFFER_SIZE) { try { wait(); } catch (InterruptedException ie) { } } buffer[in] = item; in = (in + 1) % BUFFER_SIZE; count++; notify(); }
16 . 5
![Page 123: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/123.jpg)
JAVA MONITORSJAVA MONITORS/* Consumers call this method */ public synchronized E remove() { E item; while (count == 0) { try { wait(); } catch (InterruptedException ie) { } } item = buffer[out]; out = (out + 1) % BUFFER_SIZE; count--; notify(); return item; }
16 . 6
![Page 124: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/124.jpg)
REENTRANT LOCKSREENTRANT LOCKSLock key = new ReentrantLock(); key.lock(); try { /* critical section */ } finally { key.unlock(); }
16 . 7
![Page 125: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/125.jpg)
SEMAPHORESSEMAPHORESSemaphore sem = new Semaphore(1); try { sem.acquire(); /* critical section */ } catch (InterruptedException ie) { } finally { sem.release(); }
16 . 8
![Page 126: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/126.jpg)
ALTERNATIVE APPROACHESALTERNATIVE APPROACHES
17 . 1
![Page 127: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/127.jpg)
TRANSACTIONAL MEMORYTRANSACTIONAL MEMORYoriginated in database theory
A memory transaction is a sequence of memory read–writeoperations that are atomic. If all operations in a transaction are
completed, the memory transaction is committed. Otherwise, theoperations must be aborted and rolled back.
17 . 2
![Page 128: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/128.jpg)
EXAMPLE USING LOCKSEXAMPLE USING LOCKSvoid update() { acquire(); /* Modify Shared data */ release(); }
17 . 3
![Page 129: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/129.jpg)
TRANSACTIONAL MEMORYTRANSACTIONAL MEMORYvoid update() { atomic { /* Modify Shared data */ } }
17 . 4
![Page 130: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/130.jpg)
TRANSACTIONAL MEMORYTRANSACTIONAL MEMORYtransactional memory system—not the developer is responsiblefor guaranteeing atomicity.
no locks are involved, deadlock is not possible.
can identify which statements in atomic blocks can be executedconcurrently
concurrent read access to a shared variable.
Software or hardware solution
17 . 5
![Page 131: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/131.jpg)
OPENMPOPENMPvoid update(int value) { #pragma omp critical { counter += value; } }
17 . 6
![Page 132: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/132.jpg)
FUNCTIONAL PROGRAMMING LANGUAGESFUNCTIONAL PROGRAMMING LANGUAGESC, C++, Java, and C# → imperative or procedural languages.
program state is mutable, as variables may be assigned differentvalues over time.
17 . 7
![Page 133: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/133.jpg)
FUNCTIONAL PROGRAMMING LANGUAGESFUNCTIONAL PROGRAMMING LANGUAGESErlang, Haskell, Frege and Scala → functional programminglanguages
do not maintain state.
once a variable has been de�ned and assigned a value, its value isimmutable
no issues like race conditions and deadlocks.
17 . 8
![Page 134: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/134.jpg)
QUESTIONSQUESTIONS
18 . 1
![Page 135: AND EXAMPLES) SYNCHRONIZATION (TOOLS CHAPTER 6 AND 7jamik/dm510-19/material/lecture-04.pdf · MONITORS A high-level abstraction that provides a convenient and effective mechanism](https://reader034.vdocuments.net/reader034/viewer/2022050201/5f553d01b92c4f78874a3753/html5/thumbnails/135.jpg)
BONUSBONUSExam question number 4: Synchronization (Tools andExamples)
18 . 2