Lecture 16: Memory Management

Question 1

Memory Management Unit Responsibilities

Answer 1

-Another Resource Manager Component of the OS

1. Memory Allocation:
   responsible for allocating memory to processes
2. Address Mapping:
   Necessary: 1) to run same code in different physical memory in different processes 2) to support process address space abstraction MMU responsible for mapping logical addresses generated by CPU instructions to physical addresses seen by memory controller

Question 2

Logical Addresses

Answer 2

• An abstraction of memory
• memory referenced in assembly language instructions (e.g., BR X, LOAD R2,Y)
• starts at 0, contiguous
• reality: must be mapped to physical addresses (address mapping)

Question 3

Logical Addresses Generated at:

Answer 3

1. Compile-time
   • relative addressing resolved here(e.g.:X,Y)
2. Link, load-time
   • addresses dependent on external modules resolved here
3. Execution-time
   • addresses generated by dynamic loading/linking resolved here

Question 4

Logical Address Space

Answer 4

defined by base and limit registers

Question 5

Base and Limit Registers: CPU

Answer 5

every physical memory access request must be between base and limit for that user

Question 6

Generating Physical Addresses

Answer 6

• addresses used in MAR (memory address register)
• generated at runtime (execution time) by
memory management unit (MMU)
• above protocol enables dynamic program relocation (without having to modify program code)

Question 7

Memory Allocation Goal 1: High Utilization

Answer 7

• ensure as much memory used as possible (minimize waste) (e.g.: want to use as much of street for street parking as
possible)

Question 8

Memory Allocation Goal 2: High Concurrency

Answer 8

• support as many processes as possible

e.g.: cars exit when don’t require parking any more, so others can use

Question 9

Memory Allocation Goal 3: Fast

Answer 9

-fast

Question 10

Memory allocation: contiguous

Answer 10

-no gaps

Question 11

Memory allocation: non-contiguous

Answer 11

-with gaps

Question 12

Contiguous Pros and Cons

Answer 12

Pros:

• Easy implementation
• Easy to conceptualize

Cons:
-Poor memory utilization

Question 13

Contiguous Types

Answer 13

1. Fixed Partition allocation (parking lot)

2. Variable Partition allocation (side street parking)

Question 14

Fixed Partition allocation (parking lot)

Answer 14

1. Idea:
   • divide memory a priori into fixed partitions (can vary in size) e.g.: parking lot: regular spaces, compact only, etc.
2. Allocation Policy:
   • process P arrives needing k units of space:
   choose partition (Ri) that is smallest but 3 k (best-fit)
3. Utilization Issue:
   • internal fragmentation: parts of allocated partition unused
4. Implementation:
   • requires limit and relocation registers

5.
•
In Practice: used in early batch systems:
1. knew memory needs of processes in advance
2. memory needs didn’t change much over process lifetime

Question 15

Variable Partition allocation (side street parking)

Answer 15

-Idea:
• allocate memory chunks as needed (analogous to side street parking)
-best fit
-worst fit 
-first-fit
-next-fit

Question 16

Variable Partition allocation policies

Answer 16

Allocation policies:
process P arrives needing k units of memory

a. Best-fit: choose hole that is smallest but ≥ k
b. Worst-fit: choose largest hole
c. First-fit; choose first hole with size ≥ k
d. Next-fit: choose next hole with size ≥ k

Question 17

Fragmentation types

Answer 17

1. External:
   total memory exists to satisfy request, but not contiguous.
   External fragragmentation can be periodically eliminated via compaction
2. Internal:
   allocated memory may be > requested memory. Extra memory not used

Question 18

Non-contiguous allocation

Answer 18

Idea:

Logical address space is partitioned, each partition mapping to a contiguous chunk of memory

Question 19

Non-contiguous allocation: pros and cons (compared to contiguous)

Answer 19

Pros:
• better memory utilization
by dividing address space into smaller “chunks,” more
memory fragments can be used

Cons:
• more complex implementation (not just relocation & limit registers)

Question 20

Non-contiguous schemes (3)

Answer 20

1. paging
all chunks the same size
(i.e.: chunks are physically determined)
2. segmentation
chunks are variably sized (logically determined)
3. paged segmentation
hybrid of (1) and (2)

Question 21

Page Table Implementation

Answer 21

Every Process’ Page Table:

• kept in main memory
• location kept in process (special status) registers:

Page-table base register: (PTBR)
• location of page table for process

Page-table limit register: (PTLR)
• size of process page table

Question 22

Caching

Answer 22

Use of high-speed memory to hold frequently accessed data

Question 23

Associative Memory (TLB’s)

Answer 23

1. Cache is faster than memory

2. Associative Memory permits parallel search

Question 24

Issues with paging

Answer 24

Issue #1: Two memory accesses / logical address reference

Solution: TLB
Issue #2: Very large page tables

Solution: Page the page tables!! (Multilevel Paging)

Question 25

Segmentation

Answer 25

Idea:
Segmentation
• Similar to paging but, partitions of logical address space / physical memory are variable, not fixed
-partitions based on conceptual divisions rather thαn page size

Question 26

Segmentation architecture

Answer 26

-Segment tables (one per process)
-Every process PCB holds …
1. Segment Table Base Register (STBR)
• location of segment table in memory

2. Segment Table Length Register (STLR)
   • number of segments used by program

Question 27

Advantages of segmentation

Answer 27

1. Easier to implement protection
   e. g.: Text segment should be read-only. Can add flags to segment table:
2. Read-only: Prevents writes to text segment
3. No-execute: Prevents attempts to execute entries in data segment

Paging:
Page can contain both code & data. (Protection is trickier)

2. Easier to implement sharing
   •e.g.: same text segment can be used by multiple processes concurrently

Question 28

Advantages of paging

Answer 28

1. Memory utilization
   • paging suffers from internal fragmentation but at most, 1 page / process
   • segmentation suffers from external fragmentation which over time can make much of memory unusable
2. Multilevel paging allows page tables to be non-contiguous
   • can do the same for segment tables… (paged segmentation)
   • idea: segmentation-basedallocation,buteverysegmentispaged

Question 29

Locality

Answer 29

successive memory accesses tend to be of addresses close to each other