Section 1
Preview this deck
multitasking
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
0
Favorites
0
Last updated
6 years ago
Date created
Mar 1, 2020
Cards (54)
Section 1
(50 cards)
multitasking
single user can run multiple processes
Benefits of Concurrency
run multiple apps simultaneously better resource utilization better average response time better performance
Concurrency
allows multiple applications to run at the same time (juggling)
System Call
entry point call to OS
1st Phase of OS History
Hardware expensive, humans cheap hardware: mainframes, OS: human operators Goal: efficient use of hardware
Starvation
process keeps waiting, never ran
Mutli-level feedback queue
drawback: CPU bound job may drop to the bottom of queue and stay forever unless (aged)
Program vs Process
recipe vs everything needed to cook
Master Boot Record (MBR)
The first sector on a hard drive, which contains the partition table and a program the BIOS uses to boot an OS from the drive.
FIFO
best case: all same length worst case: longest job first
P( )
atomic operation that waits for semaphore to become positive then decrement by 1
V( )
atomic operation that increments semaphore by 1 and wakes up a waiting thread at P( )
User-mode vs kernel mode
application vs execute OS
3rd Phase of OS History
Hardware very cheap, humans very expensive hardware: personal computers Goal: allowing a user to perform many tasks at the same time
multithreading
having multiple threads per address space
Cooperating Threads
- shared states - non-deterministic - non-reproducible
4th Phase of OS History
Distributed Systems Hardware: computers with networks Goal: ease of resource sharing among machines
critical section
a piece of code that only one thread can execute at a time
Per-thread States
Running - has the CPU Blocked - waiting for the I/O or another thread Ready to run - on the ready list, waiting for the CPU
Round Robin
optimizes: response time minimize: turn-around time
Semaphore
- type of lock - only non-negative integer values (0,1,2....)
process
an address space + at least one thread
Uniprogramming
running one process at a time
Thread States
program counter register values execution stacks
Lottery Scheduling
not good for real time processes
Amdahl's Law
speedup <= 1/(1-P) + P/N
Timesharing
each user can afford to own terminals to interact with machines
synchronization
uses atomic operations to ensure cooperation among threads
Operating System
a virtual machine that hides the complexity and limitations of hardware from app programmers
Thread
sequential execution stream
Atomic operation
all or nothing, once executed it will run until complete or nothing at all
Address space
contains all states necessary to run a program
Independent Threads
- no states shared with others - deterministic computation - reproducible - scheduling order does not matter
System Call Sequence
trap into kernel level set kernel mode branch table trusted code
Process creation
fork() 0 = child child pid = parent -1 = failed
Code verification
test random leaving of locks and checking locks
multiprocessing
running programs on a machine with multiple processors
Dispatching loop
threads are run from them per-CPU thread contains context switch run thread, save states, choose a new thread to run, load states from different thread
Context Switch
save states, choose a new thread to run, load states from a different thread
2nd Phase of OS History
Hardware cheap, humans expensive hardware: terminals Goal: efficient use of human resources
mutliprogramming
running multiple processes on a machine
Busy waiting
while a thread is waiting, it consumes CPU time
1st Use of Semaphores
Mutual exclusion -semaphore has initial value of 1 -P( ) before critical section -V( ) after critical section
Drawbacks of Concurrency
apps need protection from others additional coordination overhead to switch apps potential worse performance when running too many apps
Preemptive vs Non-Preemptive Scheduling
Preemptive picks the best tasks to run even after starting (SJRF) Nonpreemptive once it starts running it completes (SJF)
Booting Sequence
CPU jumps to ROM Bios runPOST copy MBR copy OS loader copy kernel image set to kernel mode jump to OS entry point
mutual exclusion
ensures one thread can do something without the interference of other threads
Race Condition
the computing outcome dependent on the schedule of the execution
Job
unit of processing
Batch System
collects a batch of jobs before processing them and printing out results
Section 2
(4 cards)