Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 21 Annotated
21 - Concurrency II (1)
Outline
Sleep and Wakeup
Producer-Consumer with Sleep / Wakeup
Semaphores
Midterm Topics
Announcements
Reading:
Producer-Consumer with Sleep / Wakeup
Semaphores
Midterm Topics
Processes
Address Space
Files
System Calls
Kernel
Processor
Mechanism
Process Switching
Creation / Termination
Mechanism
Preemptive vs Nonpreemptive
Categories / Goals
FCFS
SJF / SRTN
Round Robin
Priority Scheduling
Multiple Queues
Real-Time Schedulability
Rate Monotonic
Earliest Deadline First
Approaches
Race Conditions
Critical Sections
Interrupt Disable
Lock Variables
Strict Alternation
Peterson's Solution
40% MCQ
One, double-sided, 8.5 x 11 page handwritten notes
15% Processes/Threads
15% Concurrency
30% Scheduling
Busy-Waiting Solutions
Thread Control Block
Advantages / Disadvantages
Amdahl's Law
Creation / Termination
Process State
Process Control Block
CPU Utilization
Memory Access
Memory
I/O Devices
Buses
OS Concepts and Structures
Midterm Format
Computer Hardware
System Calls
Processes
Threads
Scheduling
Concurrency
Recap: Busy Waiting
Busy Waiting wastes CPU cycles.
What if we simply stop the process instead?
Putting the process to sleep:
Almost same as "yield" for threads
Note: processes may also be woken up by signals
Recap: Producer-Consumer Problem
One solution: Wakeup-Waiting Bit
The old incorrect solution:
Becomes:
Do we still have a problem here?
We still have a race condition on count.
Problem: this doesn't generalize with more
processes.
A semaphore is a shared data type that acts as a
shared counter variable.
How can we use this for the producer consumer
problem?
decrements the semaphore, or suspends
execution if semaphore is already 0
increments the semaphore, or wakes up a
suspended process if one is present
actual semaphore implementations vary by
kernel API
For this lecture, we'll treat the semaphore as
a shared integer for simplicity, but they
generally have much more associated state.
Add a bit to the PCB that saves a wakeup call.
The next time the process calls sleep, it will only
sleep if the bit was not set.
Wakeup signal is ignored if a process is already
awake, so both processes may end up sleeping
forever.
The issue is the lost wakeup signal!
Again, consider a single producer and single
consumer with a buffer size > 1
Software-Only Lock
(incorrect solution)
TSL Lock
producer
consumer
Sleep / Wakeup
Mid-semester feedback survey is out.
2 extra points on the midterm for 70% completion
(by section)
PA 2 grade release has been a bit delayed.
PA 3 autograder will be fixed later today.
Midterm on Friday
1)
3)
4)
2)
MOS 2.4.1 - 2.4.3
while (1) {
while (lock != 0);
lock = 1;
do_critical();
lock = 0;
do_noncritical();
}
while (1) {
enter_critical:
asm(TSL r1, lock);
asm(CMP r1, #0);
asm(JNE enter_critical);
do_critical();
exit_critical:
asm(MOV lock, #0);
do_noncritical();
}
-
-
Move the process to the blocked queue until it
is woken up again.
caller yields CPU until another process
wakes it up
caller wakes up another sleeping process
(can't wake itself up)
(wakeup ignored if redundant)
This requires syscalls, since moving a process
between states can only be done by the kernel.
sleep
wakeup
Given:
Producers and consumers share the buffer
a fixed-size buffer B with N elements
counts number of available shared resources
2 allowed operations:
Pseudocode:
Note:
Example:
counts number of events (e.g. pending wakeups)
P producer processes
producers put data in the buffer
consumers remove data from the buffer
C consumer processes
-
-
-
-
-
-
-
-
-
Producer
Consumer
Consumer
Consumer
Producer
Producer
N items
buffer B
// shared variables
const int size;
int count = 0;
item_t buffer[size];
// shared variables
const int size;
int count = 0;
item_t buffer[size];
// init:
buffer = []
count = 0
(p) line 2: A = produce()
(p) line 3: if (count == N)
(p) line 5: push(buffer, A)
(p) line 6: count++
(p) line 7: if (count == 1)
(p) line 8: wakeup(consumer)
(c) line 2: if (count == 0)
(c) line 2: sleep()
// producer
while (1) {
item_t A = produce();
while (count == size);
push(buffer, A);
count++;
}
// producer
while (1) {
item_t A = produce();
if (count == size)
sleep();
push(buffer, A);
count++;
if (count == 1)
wakeup(consumer);
}
atomic down(semaphore)
if semaphore == 0:
sleep(semaphore)
else:
semaphore--
endif
atomic up(semaphore)
if semaphore == 0
and has_sleeping(semaphore):
wakeup(semaphore)
else:
semaphore++
endif
if (count == N)
sleep();
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
3:
4:
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
// consumer
while (1) {
while (count == 0);
item_t A = pop(buffer);
count--;
consume(A);
}
// consumer
while (1) {
if (count == 0)
sleep();
item_t A = pop(buffer);
count--;
if (count == size-1)
wakeup(producer);
consume(A);
}
producer
consumer
// init:
buffer = []
count = 0
(p) line 2: A = produce()
(p) line 3: if (count == N)
(p) line 5: push(buffer, A)
(p) line 6: count++
(p) line 7: if (count == 1)
(p) line 8: wakeup(consumer)
(c) line 2: if (count == 0)
(c) line 2: sleep()
down
up
init: s = 2
proc1: down(&s)
proc1: down(&s)
proc1: down(&s)
proc2: up(&s)
proc2: up(&s)
proc1: down(&s)
proc1
proc2
Complete the diagram:
PCB and TCB separate unless otherwise stated
Time of Check,
Time of Use
running
blocked
consumer ignores wakeup
consumer sleeps
WW bit set
no sleep, unset WW bit
s = 1
s = 1
s = 0
s = 0
proc 1 sleeps
proc 1 wakeup (s = 0)