![Page 1: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/1.jpg)
CPS110: Intro to processes,
threads and concurrency
Author: Landon Cox
![Page 2: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/2.jpg)
Intro to processes
Decompose activities into separate tasks Allow them to run in parallel “Independently” (what does this mean?) “without dependencies” …
Key OS abstraction: processes Run independently of each other Don’t have to know about others
![Page 3: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/3.jpg)
Intro to processes
Remember, for any area of OS, ask What interface does the hardware provide? What interface/abstraction does the OS provide?
What is physical reality? Single computer (CPUs + memory) Execute instructions from many programs
What does an application see? Each app “thinks” it has its own CPU + memory
![Page 4: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/4.jpg)
Hardware, OS interfaces
HardwareHardware
OSOS
ApplicationsApplications
MemoryMemory CPUsCPUs
CPU, MemCPU, Mem
Job 1Job 1CPU, MemCPU, Mem
Job 2Job 2CPU, MemCPU, Mem
Job 3Job 3
![Page 5: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/5.jpg)
What is a process?
Informal A program in execution Running code + things it can read/write Process ≠ program
Formal ≥ 1 threads in their own address space (soon threads will share an address space)
![Page 6: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/6.jpg)
Parts of a process
Thread Sequence of executing instructions Active: does things
Address space Data the process uses as it runs Passive: acted upon by threads
![Page 7: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/7.jpg)
Play analogy
Process is like a play performance Program is like the play’s scriptThreads
Address space
What are the threads?
What is the address space?
![Page 8: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/8.jpg)
What is in the address space?
Program code Instructions, also called “text”
Data segment Global variables, static variables Heap (where “new” memory comes
from) Stack
Where local variables are stored
![Page 9: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/9.jpg)
Review of the stack
Each stack frame contains a function’s Local variables Parameters Return address Saved values of calling function’s
registers The stack enables recursion
![Page 10: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/10.jpg)
const1=1const2=0const1=1const2=0main
Example stack
tmp=1RA=0x804838c
tmp=1RA=0x804838cA
RA=0x8048361RA=0x8048361B
const=0RA=0x8048354
const=0RA=0x8048354C
tmp=0RA=0x8048347
tmp=0RA=0x8048347A
0xfffffff
0x0
Memory
void C () { A (0);}
void B () { C ();}
void A (int tmp){ if (tmp) B ();}
int main () { A (1); return 0;}
void C () { A (0);}
void B () { C ();}
void A (int tmp){ if (tmp) B ();}
int main () { A (1); return 0;}
0x80483470x8048347
0x80483540x8048354
0x80483610x8048361
0x804838c0x804838c
Code Stack
…
SPSP
SPSP
SPSP
SPSP
SPSP
![Page 11: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/11.jpg)
const1=3const2=0const1=3const2=0main
The stack and recursion
bnd=3RA=0x804838c
bnd=3RA=0x804838cA
bnd=2RA=0x8048361
bnd=2RA=0x8048361A
bnd=1RA=0x8048361
bnd=1RA=0x8048361A
bnd=0RA=0x8048361
bnd=0RA=0x8048361A
0xfffffff
0x0
Memory
void A (int bnd){ if (bnd) A (bnd-1);}
int main () { A (3); return 0;}
void A (int bnd){ if (bnd) A (bnd-1);}
int main () { A (3); return 0;}
0x80483610x8048361
0x804838c0x804838c
Code Stack
…
SPSP
SPSP
SPSP
SPSP
SPSP
How can recursion go wrong?Can overflow the stack …Keep adding frame after frame
![Page 12: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/12.jpg)
wrd[3]wrd[2]wrd[1]wrd[0]
const2=0
wrd[3]wrd[2]wrd[1]wrd[0]
const2=0
main
The stack and buffer overflows
b= 0x00234RA=0x804838c
b= 0x00234RA=0x804838ccap
0xfffffff
0x0
Memoryvoid cap (char* b){ for (int i=0; b[i]!=‘\0’; i++) b[i]+=32;}int main(char*arg) { char wrd[4]; strcpy(arg, wrd); cap (wrd); return 0;}
void cap (char* b){ for (int i=0; b[i]!=‘\0’; i++) b[i]+=32;}int main(char*arg) { char wrd[4]; strcpy(arg, wrd); cap (wrd); return 0;}
0x80483610x8048361
0x804838c0x804838c
Code Stack
…SPSP
SPSP
0x002340x00234What can go wrong?Can overflow wrd variable …Overwrite cap’s RA
![Page 13: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/13.jpg)
What is missing?
What process state isn’t in the address space? Registers Program counter (PC) General purpose registers
Review 104 for more details
![Page 14: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/14.jpg)
Multiple threads in an addr space
Several actors on a single set Sometimes they interact (speak,
dance) Sometimes they are apart
(different scenes)
![Page 15: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/15.jpg)
![Page 16: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/16.jpg)
Private vs global thread state
What state is private to each thread? PC (where actor is in his/her script) Stack, SP (actor’s mindset)
What state is shared? Global variables, heap (props on set) Code (like lines of a play)
![Page 17: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/17.jpg)
Looking ahead: concurrency
Concurrency Having multiple threads active at one
time Thread is the unit of concurrency
Primary topics How threads cooperate on a single task How multiple threads can share the CPU
Subject of Project 1
![Page 18: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/18.jpg)
Looking ahead: address spaces
Address space Unit of “state partitioning”
Primary topics Many addr spaces sharing physical
memory Efficiency Safety (protection)
Subject of Project 2
![Page 19: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/19.jpg)
Thread independence
Ideal decomposition of tasks: Tasks are completely independent Remember our earlier definition of independence
Is such a pure abstraction really feasible? Word saves a pdf, starts acroread, which reads the
pdf? Running mp3 player, while compiling 110 project?
Sharing creates dependencies Software resources (file, address space) Hardware resources (CPU, monitor, keyboard)
![Page 20: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/20.jpg)
True thread independence
What would pure independence actually look like? (system with no shared software, hardware resources)
Multiple computer systems Each running non-interacting programs Technically still share the power grid …
“Pure” independence is infeasible Tension between software dependencies,“features”
Key question: is the thread abstraction still useful? Easier to have one thread with multiple responsibilities?
![Page 21: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/21.jpg)
Consider a web server
One processor Multiple disks Tasks
Receives multiple, simultaneous requests
Reads web pages from disk Returns on-disk files to requester
![Page 22: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/22.jpg)
Web server (single thread)
Option 1: could handle requests serially
Easy to program, but painfully slow (why?)
Client 1 Client 2WSR1 arrivesReceive R1
R2 arrivesDisk request 1a
1a completesR1 completesReceive R2
![Page 23: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/23.jpg)
Web server (event-driven) Option 2: use asynchronous I/O Fast, but hard to program (why?)
Client 1 DiskWSR1 arrivesReceive R1
Disk request 1a
1a completes
R1 completes
Receive R2
Client 2
R2 arrives
Finish 1a
Start 1a
![Page 24: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/24.jpg)
Web server (multi-threaded)
Option 3: assign one thread per request
Where is each request’s state stored?
Client 1 Client 2WS1
R1 arrivesReceive R1
R2 arrivesDisk request 1a
1a completesR1 completes
Receive R2
WS2
![Page 25: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/25.jpg)
Threads are useful
It cannot provide total independence But it is still a useful abstraction! Threads make concurrent programming
easier Thread system manages sharing the CPU
(unlike in event-driven case) Apps can encapsulate task state w/i a
thread (e.g. web request state)
![Page 26: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/26.jpg)
Where are threads used?
When a resource is slow, don’t want to wait on it
Windowing system One thread per window, waiting for window input What is slow?
Human input, mouse, keyboard
Network file/web/DB server One thread per incoming request What is slow?
Network, disk, remote user (e.g. ATM bank customer)
![Page 27: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/27.jpg)
Where are threads used?
When a resource is slow, don’t want to wait on it
Operating system kernel One thread waits for keyboard input One thread waits for mouse input One thread writes to the display One thread writes to the printer One thread receives data from the network card One thread per disk … Just about everything except the CPU is slow
![Page 28: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/28.jpg)
Cooperating threads
Assume each thread has its own CPU We will relax this assumption later
CPUs run at unpredictable speeds Source of non-determinism
MemoryMemory
CPUCPUThread AThread A
CPUCPUThread BThread B
CPUCPUThread CThread C
![Page 29: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/29.jpg)
Non-determinism and ordering
Time
Thread A
Thread B
Thread C
Global orderingWhy do we care about the global ordering? Might have dependencies between events Different orderings can produce different resultsWhy is this ordering unpredictable? Can’t predict how fast processors will run
![Page 30: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/30.jpg)
Non-determinism example 1
Thread A: cout << “ABC”; Thread B: cout << “123”; Possible outputs?
“A1BC23”, “ABC123”, …
Impossible outputs? Why? “321CBA”, “B12C3A”, …
What is shared between threads? Screen, maybe the output buffer
![Page 31: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/31.jpg)
Non-determinism example 2
y=10; Thread A: int x = y+1; Thread B: y = y*2; Possible results?
A goes first: x = 11 and y = 20 B goes first: y = 20 and x = 21
What is shared between threads? Variable y
![Page 32: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/32.jpg)
Non-determinism example 3
x=0; Thread A: x = 1; Thread B: x = 2; Possible results?
B goes first: x = 1 A goes first: x = 2
Is x = 3 possible?
![Page 33: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/33.jpg)
Example 3, continued
What if “x = <int>;” is implemented as x := x & 0 x := x | <int>
Consider this schedule Thread A: x := x & 0 Thread B: x := x & 0 Thread B: x := x | 1 Thread A: x := x | 2
![Page 34: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/34.jpg)
Atomic operations
Must know what operations are atomic before we can reason about cooperation
Atomic Indivisible Happens without interruption
Between start and end of atomic action No events from other threads can occur
![Page 35: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/35.jpg)
Review of examples
Print example (ABC, 123) What did we assume was atomic? What if “print” is atomic? What if printing a char was not
atomic? Arithmetic example (x=y+1, y=y*2)
What did we assume was atomic?
![Page 36: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/36.jpg)
Atomicity in practice
On most machines Memory assignment/reference is atomic E.g.: a=1, a=b
Many other instructions are not atomic E.g.: double-precision floating point store (often involves two memory operations)
![Page 37: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/37.jpg)
Virtual/physical interfaces
HardwareHardware
OSOS
ApplicationsApplications
If you don’t have atomic operations, you can’t make one.
![Page 38: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/38.jpg)
Another example
Two threads (A and B) A tries to increment i B tries to decrement i
Thread A: i = o; while (i < 10){ i++; } print “A done.”
Thread B: i = o; while (i > -10){ i--; } print “B done.”
![Page 39: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/39.jpg)
Example continued
Who wins? Does someone have to win?
Thread A: i = o; while (i < 10){ i++; } print “A done.”
Thread B: i = o; while (i > -10){ i--; } print “B done.”
![Page 40: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/40.jpg)
Example continued
Will it go on forever if both threads Start at about the same time And execute at exactly the same speed? Yes, if each C statement is atomic.
Thread A: i = o; while (i < 10){ i++; } print “A done.”
Thread B: i = o; while (i > -10){ i--; } print “B done.”
![Page 41: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/41.jpg)
Example continued
What if i++/i-- are not atomic?
tmp := i+1 i := tmp (tmp is private to A and B)
![Page 42: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/42.jpg)
Example continued
Non-atomic i++/i-- If A starts ½ statement ahead, B can win
How?
Thread A: tmpA := i + 1 // tmpA == 1Thread B: tmpB := i - 1 // tmpB == -1Thread A: i := tmpA // i == 1Thread B: i := tmpB // i == -1
![Page 43: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/43.jpg)
Example continued
Non-atomic i++/i-- If A starts ½ statement ahead, B can win
How? Do you need to worry about this?
Yes!!! No matter how unlikely
![Page 44: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/44.jpg)
Debugging non-determinism
Requires worst-case reasoning Eliminate all ways for program to break
Debugging is hard Can’t test all possible interleavings Bugs may only happen sometimes
Heisenbug Re-running program may make the bug
disappear Doesn’t mean it isn’t still there!
![Page 45: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/45.jpg)
Constraining concurrency
Synchronization Controlling thread interleavings
Some events are independent No shared state Relative order of these events don’t matter
Other events are dependent Output of one can be input to another Their order can affect program results
![Page 46: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/46.jpg)
Goals of synchronization
1. All interleavings must give correct result
Correct concurrent program Works no matter how fast threads run
Important for your projects!
2. Constrain program as little as possible Why?
Constraints slow program down Constraints create complexity
![Page 47: CPS110: Intro to processes, threads and concurrency Author: Landon Cox](https://reader035.vdocuments.mx/reader035/viewer/2022062423/56649e975503460f94b9ab39/html5/thumbnails/47.jpg)
Conclusion
Next class: more cooperation “How do actors interact on stage?”
Start Project 0 Simple, designed to help you with
C++