threads and scheduling · process • “modern” process: process and thread are separated as...
TRANSCRIPT
![Page 1: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/1.jpg)
Processes andNon-Preemptive Scheduling
Otto J. Anshus
Monday, 29.August, 2011
![Page 2: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/2.jpg)
2
Concurrency and Process• Challenge: Physical reality is Concurrent
– Smart to do “concurrent software” instead of sequential?– At least we want to have many apps running on a single computer “at the same time”
• Must share CPU, memory, I/O devices• Lots of interrupts/traps/exceptions and faults (page faults) will happen
– Options• let each application/computation see the others and deal with it (each must fight or cooperate
with the others)• let each application/computation believe it has the computer all alone (analogy: each car
sees the highway without other cars (but perhaps it is a highway where the width and the speed limit can change at any time)
• Trad. approach: – Make the OS understand “process” and “threads” and give support to the
processes and threads– Now we can decompose complex problems into simpler ones
• Applications/computations are comprised of one or several processes– Cooperating processes need synchronization and communication (using message passing)
• Each process comprised of one or several
• Cooperating threads
• Synchronization and communication (using locks, semaphores, monitors)
• Deal with one at a time• Each process can believe it has a computer to itself: it can be written as if this is indeed the
case
Monday, 29.August, 2011
![Page 3: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/3.jpg)
3
Kernel
Processes
Threads
Processes
Kernel
Processes
Get input fromdevice Process input Action 2
Action 1
Action 3
Use Processes or Threads?
Monday, 29.August, 2011
![Page 4: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/4.jpg)
4
Process• An instance of a program under execution
– Program specifying (logical) control-flow (thread)– Data – Private address space– Open files– Run-time environment
• Very important operating system concept– Used for supporting the concurrent execution of independent or
cooperating program instances– Used to structure applications and systems– Unit of Protection
Kernel
Processes
Threads
Processes
Monday, 29.August, 2011
![Page 5: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/5.jpg)
5
Flow of Execution
Kernel Mode
User Mode
“Input finished” interrupt from Disk
P1: Read file syscall
P1: CPU bound
P2: CPU bound
Interrupt handling; Scheduler (selects P2); Dispatch Pselected;
Interrupt handling; Scheduler (selects P1); Dispatch Pselected;
Interrupt handling; Scheduler (selects some P); Dispatch Pselected;
Int0x80 interrupt from user level application
Timer Interrupt (repeated every 10-100ms)
(OS scheduler can select any ready process to run)
(Assume R to disk => long wait 10-100’s ms)
Time(interleaved
sequence)Monday, 29.August, 2011
![Page 6: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/6.jpg)
6
Concurrency & performance
• Common in physical reality• Speedup
– ideal: n processes, n speedup– reality: bottlenecks + overheads
• + sequential vs. parallel parts if & when the processes cooperate
– Questions• Speedup when
– working with 1 partner?– working with 10 partners? 100? 1000? 10.000? ...
• Super-linear speedup?– Also check out Amdahl’s Law
Monday, 29.August, 2011
![Page 7: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/7.jpg)
7
Procedure, Co-routine, Thread, Process
• Procedure, Function, (Sub)Routine• Call-execute all-return nesting
• Co-routine• Call-resumes-return
• Thread (more later)• Process
– Single threaded– Multi threaded
User level non preemptive “scheduler” spread “all over” user code
Monday, 29.August, 2011
![Page 8: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/8.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 9: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/9.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 10: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/10.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 11: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/11.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 12: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/12.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 13: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/13.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 14: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/14.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 15: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/15.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 16: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/16.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 17: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/17.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 18: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/18.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 19: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/19.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 20: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/20.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 21: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/21.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 22: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/22.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 23: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/23.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 24: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/24.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 25: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/25.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 26: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/26.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 27: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/27.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 28: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/28.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 29: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/29.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 30: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/30.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 31: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/31.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 32: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/32.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 33: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/33.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 34: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/34.jpg)
8
Procedure and Co-routine
Call A;Call B;
Call B;
Main A B
Call A;Call B; Resume A;
Resume B;
Main A B
Resume A;
Return
Return
Never executed
“User Yield when finished”
“User Yield during execution to share CPU”
Return
Monday, 29.August, 2011
![Page 35: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/35.jpg)
9
Process
• “Modern” process: Process and Thread are separated as concepts
• Process—Unit of Resource Allocation—Defines the context
• Thread—Control Thread—Unit of execution, scheduling
• Every process has at least one thread– Every thread exists within the context of a process?
Monday, 29.August, 2011
![Page 36: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/36.jpg)
10
Simplest (single threaded, sequential) Process
• Sequential execution of operations– No concurrency inside a (single threaded) process– Everything happens sequentially
• Process state– Registers– Stack(s)– Main memory– I/O devices
• Files and their state• Communication ports
– Other resources
Monday, 29.August, 2011
![Page 37: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/37.jpg)
11
Program and Process
main(){…foo()…bar()…baz()…qux()…quux()…}
foo(){…}bar() {…}/* a.k.a. gazonkbaz() {…}qux() {…}quux() {…} Program
main(){…foo()…bar()…baz()…qux()…quux()…}
foo(){…}bar() {…}baz() {…}qux() {…}quux() {…}
Process
heapstackmainfoo
registersPC
Resources: comm. ports,
files, semaphores
PID
For at least one thread of execution
The context
Monday, 29.August, 2011
![Page 38: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/38.jpg)
12
Process vs. Program
• Process “>” program– Program is just part of process state– Example: many users can run the same program
• Process “<“ program– A program can invoke more than one process– Example: Fork off processes
Monday, 29.August, 2011
![Page 39: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/39.jpg)
13
Process State Transitions
Running
BlockedReadySc
hedu
ler
dispa
tch Wait for
resource
Resource becomesavailable
Createa process
terminate
P4P3P2P1
P2
P1
ReadyQueue P4P3
BlockedQueue
Scheduler
Dispatcher
Trap Handler
Service
!
Current
Trap Return Handler
U s e r L e v e l P r o c e s s e s
KERNEL
MULTIPROGRAMMING
•Uniprocessor: Interleaving (“pseudoparallelism”)
•Multiprocessor: Overlapping (“true paralellism”)
PCB’s
Memory resident part
Instruction Pointer (program counter) in the EIP register
Monday, 29.August, 2011
![Page 40: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/40.jpg)
14
What needs to be saved and restored on a context switch?
• Volatile state• Program counter (Program Counter (PC) also called Instruction
Pointer (Intel: EIP))• Processor status register• Other register contents• User and kernel stack pointers• A pointer to the address space in which the process runs
• the process’s page table directory
Monday, 29.August, 2011
![Page 41: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/41.jpg)
15
Basic Flow of Context Switch
Monday, 29.August, 2011
![Page 42: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/42.jpg)
15
Basic Flow of Context Switch
• Save(volatile machine state, current process);– done by HW and Interrupt handler
Monday, 29.August, 2011
![Page 43: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/43.jpg)
15
Basic Flow of Context Switch
• Save(volatile machine state, current process);– done by HW and Interrupt handler
• Load(another process’s saved volatile state);– selecting another process is done by OS Kernel
Scheduler– loading is done by OS Kernel Dispatcher
Monday, 29.August, 2011
![Page 44: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/44.jpg)
15
Basic Flow of Context Switch
• Save(volatile machine state, current process);– done by HW and Interrupt handler
• Load(another process’s saved volatile state);– selecting another process is done by OS Kernel
Scheduler– loading is done by OS Kernel Dispatcher
• Start(new process);– done by OS Kernel Disptacher
Monday, 29.August, 2011
![Page 45: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/45.jpg)
16
Implementing processes
• OS (kernel) needs to keep track of all processes– Keep track of it’s progress– (Parent process, if such a concept has been added)– Metadata (priorities etc.) used by OS– Memory management– File management
• Process table with one entry (Process Control Block) per process
• Will also have the processes in queues
Monday, 29.August, 2011
![Page 46: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/46.jpg)
17
Make a Process
• Creation– load code and data into memory– create an empty stack– initialize state to same as after a process switch– make process READY to run
• insert into OS scheduler queue (Ready_Queue)• Clone
– Stop current process and save (its) state– make copy of currents code, data, stack and OS state– make the new process READY to run
Monday, 29.August, 2011
![Page 47: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/47.jpg)
18
Process Control Block (PCB)
• Process management info– State (ready, running, blocked)– Registers, PSW, EFLAGS, and other CPU state– Stack, code, and data segment
• Memory management info– Segments, page table, stats, etc
• I/O and file management– Communication ports, directories, file descriptors, etc.
• OS must allocate resources to each process, and do the state transitions
Monday, 29.August, 2011
![Page 48: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/48.jpg)
19
Primitives of Processes
• Creation and termination– fork, exec, wait, kill
• Signals– Action, Return, Handler
• Operations– block, yield
• Interaction– message passing
Monday, 29.August, 2011
![Page 49: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/49.jpg)
20
Threads
• thread– a sequential execution stream within a process (a.k.a.
lightweight process)– threads in a process share the same address space
• thread concurrency– easy to program overlapping of computation with I/O– supports doing many things at a time: web browser– a server serves multiple requests
Monday, 29.August, 2011
![Page 50: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/50.jpg)
21
Thread Control Block (TCB)
• state (ready, running, blocked)• registers• status (EFLAGS)• program counter (EIP)• stack• code
Monday, 29.August, 2011
![Page 51: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/51.jpg)
22
Thread API
• creation– fork, join
• mutual exclusion– acquire(lock_name), release (lock_name)
• operations on monitor condition variables– wait, signal, broadcast
• alert– alert, alertwait, testalert
Monday, 29.August, 2011
![Page 52: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/52.jpg)
23
Thread vs. Procedure
• threads may resume out of order– cannot use LIFO stack to save state– each thread has its own stack
• threads can be asynchronous– procedure is synchronous: can use compiler to save state,
and restore• multiple overlapping threads
– multiple CPUs
Monday, 29.August, 2011
![Page 53: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/53.jpg)
24
Process vs. Thread
• address space– processes do not (usually) share memory, threads in a
process do• therefore, process context switch implies getting a new
address space in place– page table and other memory mechanisms
• privileges– each process has its own set, threads in a process share
Monday, 29.August, 2011
![Page 54: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/54.jpg)
25
Threads and Processes in the Course Project OS
Kernel threads
Kernel Address Space
Kernel Level
at User Level
Project OSTrad. User-Level ThreadsSingle-threaded processes in individual address spaces
Kernel Level
User Level Thread Support
Process
Threads
Monday, 29.August, 2011
![Page 55: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/55.jpg)
26
User- and Kernel-Level Thread Support
• User-level threads within a process are– Indiscernible by OS– Scheduled by (user-level) scheduler in process
• Kernel-level threads– Maintained by OS– Scheduled by OS
Monday, 29.August, 2011
![Page 56: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/56.jpg)
27
User vs. Kernel-level Threads
• Question– What is the difference between user-level and kernel-level threads?
• Discussion– User-level threads are scheduled by a scheduler in their process at user-level
• Co-routines• Cooperative scheduling (explicit “yield” syscall, implicitly at any syscall
(Warning: shared resources can result in race conditions and deadlocks))• Timer interrupt to get preemption (Warning: shared resources)
– Kernel-level threads are scheduled by kernel scheduler– Implications
• When a user-level thread is blocked on an I/O event, the whole process is blocked
• A context switch of kernel threads is more expensive than for user threads• A smart scheduler (two-level) can avoid both drawbacks. But is more
complex– Do we like complexity?
Monday, 29.August, 2011
![Page 57: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/57.jpg)
28
Threads & Stack
• Private: Each user thread has its own kernel stack• Shared: All threads of a process share the same kernel
stack
Monday, 29.August, 2011
![Page 58: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/58.jpg)
29
When may OS switch contexts?
• Only when OS runs• Events potentially causing a context switch:
– (User level) system calls• Process created (fork)• Process exits (exit)• Process blocks implicitly (I/O calls, block/wait, IPC calls)• Process enters state ready explicitly (yield)
– System Level Trap• By HW• By SW exception
– Kernel preempts current process• Potential scheduling decision at “any of above”• +“Timer” to be able to limit running time of processes
Userprocess
Syscall/Exception
TIMER INTERRUPT (100ms)
Interrupt handler: Start service or Handle exception
InterruptHardware
Operating System Kernel
ServiceService
ServiceService
Scheduler(i) Select next process to run(ii) Restore context(iii) Run it
I/O INTERRUPT (from keyboard, floppy, other)
Userprocess
Monday, 29.August, 2011
![Page 59: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/59.jpg)
30
Context Switching Issues• Performance
– Overhead multiplied so need to keep it fast (nano vs micro vs milli seconds)
– Most time is spent SAVING and RESTORING the context of processes• Less processor state to save, the better
– Pentium has a multitasking mechanism, but SW can be faster if it saves less of the state
• How to save time on the copying of context state?– Re-map (address) instead of copy (data)
• Where to store Kernel data structures “shared” by all processes• Memory
• How to give processes a fair share of CPU time• Preemptive scheduling, time-slice defines maximum time interval
between scheduling decisions
Monday, 29.August, 2011
![Page 60: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/60.jpg)
31
Example Process State Transitions
P4P3P2P1
P2
P1
ReadyQueue P4P3
BlockedQueue
Scheduler
Dispatcher
Trap Handler
Service
!
Current
Trap Return Handler
U s e r L e v e l P r o c e s s e s
KERNEL
MULTIPROGRAMMING
•Uniprocessor: Interleaving (“pseudoparallelism”)
•Multiprocessor: Overlapping (“true paralellism”)
PC
PCB’s
Memory resident part
Running
BlockedReady
Resource becomes available(move to ready queue)
Createa process
Terminate(call scheduler)
Yield(call scheduler)
Block for resource(call scheduler)
Schedulerdispatch
Monday, 29.August, 2011
![Page 61: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/61.jpg)
32
Scheduler
• Non-preemptive scheduler invoked by syscalls (to OS Kernel)– block– yield– (fork and exit)
• The simplest form Scheduler: save current process state (store to PCB) choose next process to run dispatch (load state stored in PCB to registers, and run)• Does this work?
• PCB must be resident in memory• Remember the stacks
Monday, 29.August, 2011
![Page 62: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/62.jpg)
33
Stacks• Remember: We have only one copy of the Kernel in memory
• Here is a way to view this: all processes “execute” the same kernel code (=> Must have a kernel stack for each process)
• Used for storing parameters, return address, locally created variables in frames or activation records
• Each process– user stack– kernel stack
• always empty when process is in user mode executing instructions
• Does the Kernel need its own stack(s)?
Monday, 29.August, 2011
![Page 63: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/63.jpg)
34
More on Scheduler
Monday, 29.August, 2011
![Page 64: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/64.jpg)
34
More on Scheduler
• Should the scheduler use a special stack?
Monday, 29.August, 2011
![Page 65: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/65.jpg)
34
More on Scheduler
• Should the scheduler use a special stack?– Yes,
Monday, 29.August, 2011
![Page 66: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/66.jpg)
34
More on Scheduler
• Should the scheduler use a special stack?– Yes,
• because a user process can overflow and it would require another stack to deal with stack overflow
Monday, 29.August, 2011
![Page 67: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/67.jpg)
34
More on Scheduler
• Should the scheduler use a special stack?– Yes,
• because a user process can overflow and it would require another stack to deal with stack overflow
• (because it makes it simpler to pop and push to rebuild a process’s context)
Monday, 29.August, 2011
![Page 68: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/68.jpg)
34
More on Scheduler
• Should the scheduler use a special stack?– Yes,
• because a user process can overflow and it would require another stack to deal with stack overflow
• (because it makes it simpler to pop and push to rebuild a process’s context)
• (Must have a stack when booting…)
Monday, 29.August, 2011
![Page 69: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/69.jpg)
34
More on Scheduler
• Should the scheduler use a special stack?– Yes,
• because a user process can overflow and it would require another stack to deal with stack overflow
• (because it makes it simpler to pop and push to rebuild a process’s context)
• (Must have a stack when booting…)
• Should the scheduler simply be a “kernel process” (kernel thread)?
Monday, 29.August, 2011
![Page 70: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/70.jpg)
34
More on Scheduler
• Should the scheduler use a special stack?– Yes,
• because a user process can overflow and it would require another stack to deal with stack overflow
• (because it makes it simpler to pop and push to rebuild a process’s context)
• (Must have a stack when booting…)
• Should the scheduler simply be a “kernel process” (kernel thread)?– You can view it that way because it has a stack, code and its data
structure
Monday, 29.August, 2011
![Page 71: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/71.jpg)
34
More on Scheduler
• Should the scheduler use a special stack?– Yes,
• because a user process can overflow and it would require another stack to deal with stack overflow
• (because it makes it simpler to pop and push to rebuild a process’s context)
• (Must have a stack when booting…)
• Should the scheduler simply be a “kernel process” (kernel thread)?– You can view it that way because it has a stack, code and its data
structure– This thread always runs when there is no user process
Monday, 29.August, 2011
![Page 72: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/72.jpg)
34
More on Scheduler
• Should the scheduler use a special stack?– Yes,
• because a user process can overflow and it would require another stack to deal with stack overflow
• (because it makes it simpler to pop and push to rebuild a process’s context)
• (Must have a stack when booting…)
• Should the scheduler simply be a “kernel process” (kernel thread)?– You can view it that way because it has a stack, code and its data
structure– This thread always runs when there is no user process
• “Idle” process
Monday, 29.August, 2011
![Page 73: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/73.jpg)
34
More on Scheduler
• Should the scheduler use a special stack?– Yes,
• because a user process can overflow and it would require another stack to deal with stack overflow
• (because it makes it simpler to pop and push to rebuild a process’s context)
• (Must have a stack when booting…)
• Should the scheduler simply be a “kernel process” (kernel thread)?– You can view it that way because it has a stack, code and its data
structure– This thread always runs when there is no user process
• “Idle” process– In kernel or at user level?
Monday, 29.August, 2011
![Page 74: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/74.jpg)
35
Process Context Switch
• save a context– all registers (general purpose ad floating-point)– all co-processor state– save all memory to disk?– what about cache and TLB?
• start a context: reverse of above• challenge: save state without changing it before it is saved
– hardware will save a few registers when an interrupt happens. We can use them.
– CISC: have a special instruction to save and restore all registers to/from stack
– RISC: reserve registers for kernel
Monday, 29.August, 2011
![Page 75: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/75.jpg)
36
Where Should PCB Be Kept?
Monday, 29.August, 2011
![Page 76: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/76.jpg)
36
Where Should PCB Be Kept?
• Save the PCB on user stack
Monday, 29.August, 2011
![Page 77: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/77.jpg)
36
Where Should PCB Be Kept?
• Save the PCB on user stack– Many processors have a special instruction to do it
efficiently
Monday, 29.August, 2011
![Page 78: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/78.jpg)
36
Where Should PCB Be Kept?
• Save the PCB on user stack– Many processors have a special instruction to do it
efficiently– But, need to deal with the overflow problem
Monday, 29.August, 2011
![Page 79: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/79.jpg)
36
Where Should PCB Be Kept?
• Save the PCB on user stack– Many processors have a special instruction to do it
efficiently– But, need to deal with the overflow problem– When the process terminates, the PCB vanishes
Monday, 29.August, 2011
![Page 80: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/80.jpg)
36
Where Should PCB Be Kept?
• Save the PCB on user stack– Many processors have a special instruction to do it
efficiently– But, need to deal with the overflow problem– When the process terminates, the PCB vanishes
• Save the PCB on the kernel heap data structure
Monday, 29.August, 2011
![Page 81: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/81.jpg)
36
Where Should PCB Be Kept?
• Save the PCB on user stack– Many processors have a special instruction to do it
efficiently– But, need to deal with the overflow problem– When the process terminates, the PCB vanishes
• Save the PCB on the kernel heap data structure– May not be as efficient as saving it on stack
Monday, 29.August, 2011
![Page 82: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/82.jpg)
36
Where Should PCB Be Kept?
• Save the PCB on user stack– Many processors have a special instruction to do it
efficiently– But, need to deal with the overflow problem– When the process terminates, the PCB vanishes
• Save the PCB on the kernel heap data structure– May not be as efficient as saving it on stack– But, it is very flexible and no other problems
Monday, 29.August, 2011
![Page 83: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/83.jpg)
37
Job swapping
• The processes competing for resources may have combined demands that results in poor system performance
• Reducing the degree of multiprogramming by moving some processes to disk, and temporarily not consider them for execution may be a strategy to enhance overall system performance
Monday, 29.August, 2011
![Page 84: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/84.jpg)
38
Add Job Swapping toState Transition Diagram
Running
BlockedReady
Createa process
Terminate(call scheduler)
Yield(call scheduler)
Block for resource(call scheduler)
Schedulerdispatch
Swap out
Monday, 29.August, 2011
![Page 85: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/85.jpg)
38
Add Job Swapping toState Transition Diagram
Running
BlockedReady
Createa process
Terminate(call scheduler)
Yield(call scheduler)
Block for resource(call scheduler)
Schedulerdispatch
Resource becomes available(move to ready queue) Swap out
Swap inSwapped
Swap out
Monday, 29.August, 2011
![Page 86: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/86.jpg)
39
Concurrent Programming w/ Processes
• Clean programming model– User address space is private
• Processes are protected from each other• Sharing requires some sort of IPC (InterProcess
Communication)• Overhead (slower execution)
– Process switch, process control expensive – IPC expensive
Monday, 29.August, 2011
![Page 87: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/87.jpg)
40
Revisit Monolithic OS Structure• All processes share the same kernel• Kernel comprises
– Interrupt handler & Scheduler– Key drivers– Threads “doing stuff”– Process & thread abstraction
realization– Boot loader, BIOS
• Scheduler– Use a ready queue to hold all
ready threads (==“process” if single-threaded)
– Schedule a thread in • current • or a new context
Monday, 29.August, 2011
![Page 88: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/88.jpg)
40
Revisit Monolithic OS Structure• All processes share the same kernel• Kernel comprises
– Interrupt handler & Scheduler– Key drivers– Threads “doing stuff”– Process & thread abstraction
realization– Boot loader, BIOS
• Scheduler– Use a ready queue to hold all
ready threads (==“process” if single-threaded)
– Schedule a thread in • current • or a new context
We will have: Single threaded processes
Monday, 29.August, 2011
![Page 89: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/89.jpg)
40
Revisit Monolithic OS Structure• All processes share the same kernel• Kernel comprises
– Interrupt handler & Scheduler– Key drivers– Threads “doing stuff”– Process & thread abstraction
realization– Boot loader, BIOS
• Scheduler– Use a ready queue to hold all
ready threads (==“process” if single-threaded)
– Schedule a thread in • current • or a new context
We will have: Single threaded processes
Monday, 29.August, 2011
![Page 90: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/90.jpg)
40
Revisit Monolithic OS Structure• All processes share the same kernel• Kernel comprises
– Interrupt handler & Scheduler– Key drivers– Threads “doing stuff”– Process & thread abstraction
realization– Boot loader, BIOS
• Scheduler– Use a ready queue to hold all
ready threads (==“process” if single-threaded)
– Schedule a thread in • current • or a new context
We will have: Single threaded processes
Monday, 29.August, 2011
![Page 91: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/91.jpg)
40
Revisit Monolithic OS Structure• All processes share the same kernel• Kernel comprises
– Interrupt handler & Scheduler– Key drivers– Threads “doing stuff”– Process & thread abstraction
realization– Boot loader, BIOS
• Scheduler– Use a ready queue to hold all
ready threads (==“process” if single-threaded)
– Schedule a thread in • current • or a new context
We will have: Single threaded processes
We will have: Kernel with multiple threads (kind of)
Monday, 29.August, 2011
![Page 92: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/92.jpg)
40
Revisit Monolithic OS Structure• All processes share the same kernel• Kernel comprises
– Interrupt handler & Scheduler– Key drivers– Threads “doing stuff”– Process & thread abstraction
realization– Boot loader, BIOS
• Scheduler– Use a ready queue to hold all
ready threads (==“process” if single-threaded)
– Schedule a thread in • current • or a new context
We will have: Single threaded processes
We will have: Kernel with multiple threads (kind of)
Monday, 29.August, 2011
![Page 93: Threads and Scheduling · Process • “Modern” process: Process and Thread are separated as concepts • Process—Unit of Resource Allocation—Defines the context • Thread—Control](https://reader036.vdocuments.us/reader036/viewer/2022063018/5fda9666bb426017793c7f97/html5/thumbnails/93.jpg)
40
Revisit Monolithic OS Structure• All processes share the same kernel• Kernel comprises
– Interrupt handler & Scheduler– Key drivers– Threads “doing stuff”– Process & thread abstraction
realization– Boot loader, BIOS
• Scheduler– Use a ready queue to hold all
ready threads (==“process” if single-threaded)
– Schedule a thread in • current • or a new context
We will have: Single threaded processes
We will have: Kernel with multiple threads (kind of)
Monday, 29.August, 2011