CS 4410 Review

1
CS 4410 Review
2
Announcements

• Homework 6 Due today, Tuesday, December 2nd
• See me after class to pick up prelim II
• Upcoming Agenda
• This week is last week of classesDecember 2nd
  and 4th
• FinalThursday, December 18th at 2pm
• Room 131 Warren Hall
• Length is 2 ½ hrs
• Email to confirm office hours

3
Goals for Today

• Review half the book
• Make sure intuition is clear
• Ask questions
• For more detailed information
• Use past slides, redo homework and prelims

4
Operating System Definition
Definition An Operating System (OS) provides a
virtual machine on top of the real hardware,
whose interface is more convenient than the raw
hardware interface.
Applications
OS interface
Operating System
Physical machine interface
Hardware
Advantages Easy to use, simpler to code, more
reliable, more secure, You can say I want to
write XYZ into file ABC
5
What is in an OS?
Quake
Sql Server
Applications
Windowing graphics
Shells
System Utils
OS Interface
Naming
Windowing Gfx
Operating System Services
Virtual Memory
Networking
Access Control
Generic I/O
File System
Process Management
Memory Management
Device Drivers
Physical m/c Intf
Interrupts, Cache, Physical Memory, TLB, Hardware
Devices
Logical OS Structure
6
Crossing Protection Boundaries

• User calls OS procedure for privileged
  operations
• Calling a kernel mode service from user mode
  program
• Using System Calls
• System Calls switches execution to kernel mode

User Mode Mode bit 1
Resume process
User process
System Call
Trap Mode bit 0
Kernel Mode Mode bit 0
Return Mode bit 1
Save Callers state
Execute system call
Restore state
7
What is a process?

• The unit of execution
• The unit of scheduling
• Thread of execution address space
• Is a program in execution
• Sequential, instruction-at-a-time execution of a
  program.
• The same as job or task or sequential
  process

8
Process State Transitions
interrupt
New
Exit
admitted
done
Ready
Running
dispatch
I/O or event completion
I/O or event wait
Waiting

• Processes hop across states as a result of
• Actions they perform, e.g. system calls
• Actions performed by OS, e.g. rescheduling
• External actions, e.g. I/O

9
Context Switch

• For a running process
• All registers are loaded in CPU and modified
• E.g. Program Counter, Stack Pointer, General
  Purpose Registers
• When process relinquishes the CPU, the OS
• Saves register values to the PCB of that process
• To execute another process, the OS
• Loads register values from PCB of that process
• Context Switch
• Process of switching CPU from one process to
  another
• Very machine dependent for types of registers

10
Threads and Processes

• Most operating systems therefore support two
  entities
• the process,
• which defines the address space and general
  process attributes
• the thread,
• which defines a sequential execution stream
  within a process
• A thread is bound to a single process.
• For each process, however, there may be many
  threads.
• Threads are the unit of scheduling
• Processes are containers in which threads execute

11
Schedulers

• Process migrates among several queues
• Device queue, job queue, ready queue
• Scheduler selects a process to run from these
  queues
• Long-term scheduler
• load a job in memory
• Runs infrequently
• Short-term scheduler
• Select ready process to run on CPU
• Should be fast
• Middle-term scheduler
• Reduce multiprogramming or memory consumption

12
CPU Scheduling Algorithms

• FCFS
• LIFO
• SJF
• SRTF
• Priority Scheduling
• Round Robin
• Multi-level Queue
• Multi-level Feedback Queue

13
CPU Scheduling Metrics

• CPU utilization percentage of time the CPU is
  not idle
• Throughput completed processes per time unit
• Turnaround time submission to completion
• Waiting time time spent on the ready queue
• Response time response latency

14
Race conditions

• Definition timing dependent error involving
  shared state
• Whether it happens depends on how threads
  scheduled
• Hard to detect
• All possible schedules have to be safe
• Number of possible schedule permutations is huge
• Some bad schedules? Some that will work
  sometimes?
• they are intermittent
• Timing dependent small changes can hide bug

15
The Fundamental Issue Atomicity

• Our atomic operation is not done atomically by
  machine
• E.g. incrementing a variable by one (i) is
  three machine instructions (load, increment,
  store).
• Process can be interrupted between any machine
  instruction
• Atomic Unit instruction sequence guaranteed to
  execute indivisibly
• Also called critical section (CS)
• When 2 processes want to execute their Critical
  Section,
• One process finishes its CS before other is
  allowed to enter

16
Critical Section Problem

• Problem Design a protocol for processes to
  cooperate, such that only one process is in its
  critical section
• How to make multiple instructions seem like one?

CS1
Process 1 Process 2
CS2
Time ?
Processes progress with non-zero speed, no
assumption on clock speed Used extensively in
operating systems Queues, shared variables,
interrupt handlers, etc.
17
Solution Structure
Shared vars Initialization Process . . . .
. . Entry Section Critical Section Exit
Section
Added to solve the CS problem
18
Solution Requirements

• Mutual Exclusion
• Only one process can be in the critical section
  at any time
• Progress
• Decision on who enters CS cannot be indefinitely
  postponed
• No deadlock
• Bounded Waiting
• Bound on times others can enter CS, while I am
  waiting
• No livelock
• Also efficient (no extra resources), fair,
  simple,

19
Semaphores

• Non-negative integer with atomic increment and
  decrement
• Integer S that (besides init) can only be
  modified by
• P(S) or S.wait() decrement or block if already 0
• V(S) or S.signal() increment and wake up process
  if any
• These operations are atomic

semaphore S P(S) while(S 0)
S--
V(S) S
20
Semaphore Types

• Counting Semaphores
• Any integer
• Used for synchronization
• Binary Semaphores
• Value 0 or 1
• Used for mutual exclusion (mutex)

Process i P(S) Critical Section V(S)
Shared semaphore S Init S 1
21
Mutexes and Synchronization
semaphore S P(S) while(S 0)
S--
Init S 1
Init S 0
Process i P(S) Code XYZ V(S)
Process j P(S) Code ABC V(S)
V(S) S
22
Monitors

• Hoare 1974
• Abstract Data Type for handling/defining shared
  resources
• Comprises
• Shared Private Data
• The resource
• Cannot be accessed from outside
• Procedures that operate on the data
• Gateway to the resource
• Can only act on data local to the monitor
• Synchronization primitives
• Among threads that access the procedures

23
Synchronization Using Monitors

• Defines Condition Variables
• condition x
• Provides a mechanism to wait for events
• Resources available, any writers
• 3 atomic operations on Condition Variables
• x.wait() release monitor lock, sleep until woken
  up
• ? condition variables have waiting queues too
• x.notify() wake one process waiting on condition
  (if there is one)
• No history associated with signal
• x.broadcast() wake all processes waiting on
  condition
• Useful for resource manager
• Condition variables are not Boolean
• If(x) then does not make sense

24
Types of Monitors

• What happens on notify()
• Hoare signaler immediately gives lock to waiter
  (theory)
• Condition definitely holds when waiter returns
• Easy to reason about the program
• Mesa signaler keeps lock and processor
  (practice)
• Condition might not hold when waiter returns
• Fewer context switches, easy to support broadcast
• Brinch Hansen signaler must immediately exit
  monitor
• So, notify should be last statement of monitor
  procedure

25
Deadlocks

• Definition
• Deadlock exists among a set of processes if
• Every process is waiting for an event
• This event can be caused only by another process
  in the set
• Event is the acquire of release of another
  resource

One-lane bridge
26
Four Conditions for Deadlock

• Coffman et. al. 1971
• Necessary conditions for deadlock to exist
• Mutual Exclusion
• At least one resource must be held is in
  non-sharable mode
• Hold and wait
• There exists a process holding a resource, and
  waiting for another
• No preemption
• Resources cannot be preempted
• Circular wait
• There exists a set of processes P1, P2, PN,
  such that
• P1 is waiting for P2, P2 for P3, . and PN for P1
• All four conditions must hold for deadlock to
  occur

27
Dealing with Deadlocks

• Proactive Approaches
• Deadlock Prevention
• Negate one of 4 necessary conditions
• Prevent deadlock from occurring
• Deadlock Avoidance
• Carefully allocate resources based on future
  knowledge
• Deadlocks are prevented
• Reactive Approach
• Deadlock detection and recovery
• Let deadlock happen, then detect and recover from
  it
• Ignore the problem
• Pretend deadlocks will never occur
• Ostrich approach

28
Safe State

• A state is said to be safe, if it has a process
  sequence
• P1, P2,, Pn, such that for each Pi,
• the resources that Pi can still request can be
  satisfied by the currently available resources
  plus the resources held by all Pj, where j lt i
• State is safe because OS can definitely avoid
  deadlock
• by blocking any new requests until safe order is
  executed
• This avoids circular wait condition
• Process waits until safe state is guaranteed

29
Bankers Algorithm

• Decides whether to grant a resource request.
• Data structures
• n integer of processes
• m integer of resources
• available1..m availablei is of avail
  resources of type i
• max1..n,1..m max demand of each Pi for each Ri
• allocation1..n,1..m current allocation of
  resource Rj to Pi
• need1..n,1..m max resource Rj that Pi may
  still request
• let requesti be vector of of resource Rj
  Process Pi wants

30
Basic Algorithm

• If requesti gt needi then
• error (asked for too much)
• If requesti gt available then
• wait (cant supply it now)
• Resources are available to satisfy the request
• Lets assume that we satisfy the request. Then
  we would have
• available available - requesti
• allocationi allocation i requesti
• needi need i - request i
• Now, check if this would leave us in a safe
  state
• if yes, grant the request,
• if no, then leave the state as is and cause
  process to wait.

31
Memory Management Issues

• Protection Errors in process should not affect
  others
• Transparency Should run despite memory
  size/location

Translation box (MMU)
legal addr? Illegal?
Physical address
Load Store
Physical memory
virtual address
CPU
fault
data
How to do this mapping?
32
Scheme 1 Load-time Linking

• Link as usual, but keep list of references
• At load time determine the new base address
• Accordingly adjust all references (addition)
• Issues handling multiple segments, moving in
  memory

OS
static a.out
0x3000
0x6000
jump 0x2000
jump 0x5000
jump 0x2000
0x4000
0x1000
33
Scheme 2 Execution-time Linking

• Use hardware (base limit reg) to solve the
  problem
• Done for every memory access
• Relocation physical address logical (virtual)
  address base
• Protection is virtual address lt limit?
• When process runs, base register 0x3000, bounds
  register 0x2000. Jump addr 0x2000 0x3000
  0x5000

OS
a.out
0x6000
0x3000
MMU
a.out
Base 0x3000 Limit 0x2000
jump 0x2000
jump 0x2000
0x4000
0x1000
34
Segmentation

• Processes have multiple base limit registers
• Processes address space has multiple segments
• Each segment has its own base limit registers
• Add protection bits to every segment

Real memory
gcc
0x1000 0x3000 0x5000 0x6000
0x2000 0x8000 0x6000

Text seg r/o
BaseLimit?
Stack seg r/w
How to do the mapping?
35
Mapping Segments

• Segment Table
• An entry for each segment
• Is a tuple ltbase, limit, protectiongt
• Each memory reference indicates segment and offset

36
Fragmentation

• The inability to use free memory
• External Fragmentation
• Variable sized pieces ? many small holes over
  time
• Internal Fragmentation
• Fixed sized pieces ? internal waste if entire
  piece is not used

External fragmentation
gcc
Word
??
emacs
Unused (internal fragmentation)
allocated
stack
doom
37
Paging

• Divide memory into fixed size pieces
• Called frames or pages
• Pros easy, no external fragmentation

Pages typical 4k-8k
gcc
emacs
internal frag
38
Mapping Pages

• If 2m virtual address space, 2n page size
• (m - n) bits to denote page number, n for offset
  within page
• Translation done using a Page Table

Virtual addr
mem
((1ltlt12)128)
3 128 (12bits)
0x1000
VPN page offset
128
page table
seg
Prot VPN PPN
?
PPN
invalid
r 3 1
39
Paging Segmentation

• Paged segmentation
• Handles very long segments
• The segments are paged
• Segmented Paging
• When the page table is very big
• Segment the page table
• Lets consider System 370 (24-bit address space)

40
What is virtual memory?

• Each process has illusion of large address space
• 232 for 32-bit addressing
• However, physical memory is much smaller
• How do we give this illusion to multiple
  processes?
• Virtual Memory some addresses reside in disk

41
Virtual Memory

• Load entire process in memory (swapping), run it,
  exit
• Is slow (for big processes)
• Wasteful (might not require everything)
• Solutions partial residency
• Paging only bring in pages, not all pages of
  process
• Demand paging bring only pages that are required
• Where to fetch page from?
• Have a contiguous space in disk swap file
  (pagefile.sys)

42
Page Faults

• On a page fault
• OS finds a free frame, or evicts one from memory
  (which one?)
• Want knowledge of the future?
• Issues disk request to fetch data for page (what
  to fetch?)
• Just the requested page, or more?
• Block current process, context switch to new
  process (how?)
• Process might be executing an instruction
• When disk completes, set present bit to 1, and
  current process in ready queue

43
Page Replacement Algorithms

• Random Pick any page to eject at random
• Used mainly for comparison
• FIFO The page brought in earliest is evicted
• Ignores usage
• Suffers from Beladys Anomaly
• Fault rate could increase on increasing number of
  pages
• E.g. 0 1 2 3 0 1 4 0 1 2 3 4 with frame sizes 3
  and 4
• OPT Beladys algorithm
• Select page not used for longest time
• LRU Evict page that hasnt been used the longest
• Past could be a good predictor of the future

44
Thrashing

• Processes in system require more memory than is
  there
• Keep throwing out page that will be referenced
  soon
• So, they keep accessing memory that is not there
• Why does it occur?
• No good reuse, past ! future
• There is reuse, but process does not fit
• Too many processes in the system

45
Approach 1 Working Set

• Peter Denning, 1968
• Defines the locality of a program
• pages referenced by process in last T seconds of
  execution considered to comprise its working set
• T the working set parameter
• Uses
• Caching size of cache is size of WS
• Scheduling schedule process only if WS in memory
• Page replacement replace non-WS pages

46
Working Sets

• The working set size is num pages in the working
  set
• the number of pages touched in the interval (t,
  t-?).
• The working set size changes with program
  locality.
• during periods of poor locality, you reference
  more pages.
• Within that period of time, you will have a
  larger working set size.
• Dont run process unless working set is in memory.

47
Approach 2 Page Fault Frequency

• thrashing viewed as poor ratio of fetch to work
• PFF page faults / instructions executed
• if PFF rises above threshold, process needs more
  memory
• not enough memory on the system? Swap out.
• if PFF sinks below threshold, memory can be taken
  away

48
Allocation and deallocation

• What happens when you call
• int p (int )malloc(2500sizeof(int))
• Allocator slices a chunk of the heap and gives it
  to the program
• free(p)
• Deallocator will put back the allocated space to
  a free list
• Simplest implementation
• Allocation increment pointer on every allocation
• Deallocation no-op
• Problems lots of fragmentation

heap (free memory)
allocation
current free position
49
Memory Allocator

• What allocator has to do
• Maintain free list, and grant memory to requests
• Ideal no fragmentation and no wasted time
• What allocator cannot do
• Control order of memory requests and frees
• A bad placement cannot be revoked
• Main challenge avoid fragmentation

a
b
malloc(20)?
50
What happens on free?

• Identify size of chunk returned by user
• Change sign on both signatures (make ve)
• Combine free adjacent chunks into bigger chunk
• Worst case when there is one free chunk before
  and after
• Recalculate size of new free chunk
• Update the signatures
• Dont really need to erase old signatures

51
Example

• Initially one chunk, split and make signs
  negative on malloc

p malloc(2 sizeof (int))
52
Example

• q gets 4 words, although it requested for 3

q malloc(3 sizeof (int))
p malloc(2 sizeof (int))
53
Design features

• Which free chunks should service request
• Ideally avoid fragmentation requires future
  knowledge
• Split free chunks to satisfy smaller requests
• Avoids internal fragmentation
• Coalesce free blocks to form larger chunks
• Avoids external fragmentation

54
Malloc OS memory management

• Relocation
• OS allows easy relocation (change page table)
• Placement decisions permanent at user level
• Size and distribution
• OS small number of large objects
• Malloc huge number of small objects

heap
stack
data
code
55
Hand back prelims