VM

Question 1

issues with sharing pmem

Answer 1

protection, transparency, resource exhaustion

Question 2

protection

Answer 2

prevent processes from observing other process’ memory
e.g. bug in one process should not affect another

Question 3

transparency

Answer 3

a process should not require particular physical addresses
but we often need contiguous addresses

Question 4

resource exhaustion

Answer 4

programmers typically assume the system has enough memory
the sum of all processes is usually greater than pmem

Question 5

MMU jobs

Answer 5

1. translate virtual to physical
2. enforce memory protection
3. allow programs to see more memory than exists

Question 6

load-time linking idea

Answer 6

determine where a process will reside in memory and adjust all references within the program

Question 7

problems with load-time linking

Answer 7

how to protect?
how to relocate?
what if no contiguous free region?

Question 8

base/bound idea

Answer 8

easy relocation by changing base
must save/restore base/bound on context switches

Question 9

advantages of base/bound

Answer 9

inexpensive in hardware
inexpensive in cycles

Question 10

disadvantages of base/bound

Answer 10

growing a process is expensive/impossible
no way to share code/data

Question 11

segmentation idea

Answer 11

let processes have many base/bounds

Question 12

segmentation advantages

Answer 12

allows multiple segments per process
allows sharing of code/data
don’t need entire process in memory

Question 13

disadvantages of segmentation

Answer 13

requires address translation hardware, limits performance
segments not completely transparent e.g. default segment faster
n byte segment needs b contiguous bytes of pmem
fragmentation

Question 14

hardware lookup algorithm

Answer 14

KMPVRN

Question 15

paging tradeoffs

Answer 15

eliminates external fragmentation
simplifies allocation, free, and backing storage
avg internal frag of 0.5 pages per “segment”

Question 16

why is the MIPS UTLB handler separate from general exception handler?

Answer 16

UTLBs very frequent, hand optimized path
64 entry TLB only 256kiB
modern working sets don’t fit

Question 17

why do we typically not want paging and segmentation?

Answer 17

too much overhead

Question 18

when is paging + segmentation useful?

Answer 18

detect stack overflow or thread-local storage

Question 19

what does thread-local storage do?

Answer 19

changes a global var to local for each thread

Question 20

how is thread-local storage achieved?

Answer 20

global var relative to %fs register, each thread has its own base address stored in %fs

Question 21

what happens to the TLB on a context switch?

Answer 21

old x86 flushes TLB
MIPS tags each entry with PID, no need to flush

Question 22

where does the OS live?

Answer 22

kernel addresses are in the same address space as the user process

Question 23

what’s demand paging?

Answer 23

only loading pages if they are needed

Question 24

what’s copy on write?

Answer 24

share a reference, (fork, mmap) if a write happens, then make a copy

Question 25

what do we need zeroed pages for?

Answer 25

stack, heap, anonymously mmapped memory for devices

Question 26

what's Belady's anomaly?

Answer 26

adding more physical memory doesn't always mean fewer faults

Question 27

thrashing

Answer 27

application constantly swapping pages in and out, preventing reasonable progress

Question 28

reasons for thrashing?

Answer 28

memory access does not exhibit temporal locality working set does not fit in physical memory each process fits individually, but there are too many for the system

Question 29

what's the breakpoint?

Answer 29

top of the heap addresses between breakpoint and top of the stack are invalid

Question 30

char * brk(const char * addr);

Answer 30

set and return new value of breakpoint

Question 31

char * sbrk(int incr)

Answer 31

increment value of the breakpoint and return the old value

Question 32

void * mmap(void * addr, size_t len, int prot, int flags, int fd, off_t offset)

Answer 32

treat a file as if it were memory map fd to addr except that changes are backed up to the file **can be shared with other processes** prot specifies protection of region flags sets who can see modifications

Question 33

vm tricks at user level

Answer 33

use mprotect and sigaction to set protections and actions e.g. OO database bring in objects on demand, keep track of dirty objects, manage memory as a cache for a huge object DB

Question 34

paging in day to day use

Answer 34

demand paging copy on write growing the stack BSS page allocations sharing text/library sharing memory