Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 27 Annotated
27 - Memory Management
Outline
Processes in Physical Memory
Recap: Processes and Memory
Announcements
Reading:
Swapping
Memory Fragmentation
Processes in Physical Memory
Each process has memory
it must exist in.
No abstractions
Address spaces
Virtual memory
Improved paging
Swapping
Managing Free Memory
Paging
Translation lookaside buffer
Shares physical memory with kernel
No isolation! program may tamper with kernel
Kernel acts more like a library
e.g. MSDOS, many embedded systems
Multilevel page tables
How does process memory get implemented on
physical memory?
Program is loaded directly into physical memory and
has direct access.
Multiple programs with no abstractions, limits size
of process memory.
Issue: Program location
Relocation Problem
Program memory addresses
need to be made
relocatable.
Additional information
included in executable
No protection (no security)
Relocation expensive
(rewrite every absolute memory location)
Loader decides where to
place programs and must
rewrite program
locations at runtime.
Compiler needs to compute address locations for
memory operations. Shifting executable's location
could break program behavior.
Physical memory (RAM) is a hardware array of
words
Increasing physical RAM extends the array.
Address Spaces
1)
3)
4)
2)
MOS 3.1 - 3.2
Will release midterm grades today.
PA 4 due Friday
No class Friday
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Words are hardware-defined, fixed number of
bytes (usually now 64-bit)
stack
data
text
...
word
word
word
word
...
0x00000
0x10000
No Abstractions
Address Spaces
Base and Limit (Bound) Registers
Swapping
Memory Fragmentation
Compaction
Process Growth
user
program
user
program
user
program
...
user
program
user
program
program B
user
program
user
program
program A
user
program
OS
OS
OS
OS
OS
jmp 0x0C
jmp 0x0C
jmp 0x10
jmp 0x10
mov
mov
add
add
cmp
cmp
...
...
...
...
...
...
...
...
...
RAM Layout
RAM Layout
Kernel can be
loaded at low
addresses or high
addresses
alongside program.
Kernel can be
loaded at low
addresses or high
addresses
alongside program.
0x0000
0x0000
0x0000
0x0000
0x0000
0x0000
0x1000
0x000C
0x000C
0x0010
0x0010
0x0010
0x1010
0x1000
0x1000
0x1000
0x2000
program A
program B
physical
memory
B
A
-
-
-
-
absolute jump
breaks B
absolute jump
OK in A
0x1010
Problems:
Virtual Address Spaces
From the previous figure, how did the loader
compute the relocated absolute addresses?
MMU computes relocated addresses on-the-fly
using base and limit registers
These are saved in the PCB and loaded to the
MMU during context switching.
Using Base & Limit registers is an older way of
implementing address spaces. Modern machines use
a different scheme.
What do we do when main memory is full?
abstraction from physical memory
base register: program's loaded base address
limit register: program's maximum size
programs compile relative to 0x0 address
dedicated hardware support for relocation
Memory Management Unit (MMU)
-
-
-
-
-
limit
(program size)
base
(program base)
process 1
address
0x0f00
0x1000
0x0010
+
yes
no
OOB,
raise memory
fault
address
< limit ?
MMU
...
...
partition 1
partition 2
partition 0
physical
memory
program B:
jmp 0x10
0x0000
0x1000
0x1f00
MMU performs address translation
Swapping
Details
Storing the actual data can be done via file or
dedicated disk partition
Process creation,
termination, and swapping
creates free gaps in memory.
Swapping is performed by the kernel
Too many active processes forces swapping of
process in ready queue, serious performance
penalties.
Process becomes idle when blocked "a long time"
When swapped out, process memory no longer in
RAM, except for PCB
new process may not fit
in an available gap, even if
there is enough total free
memory
available memory become
"fragmented"
arrange process tightly to
have one large free gap
hope new gap large
enough for new process
save address space of idle process to disk and
reclaim memory (swap out process)
when ready to run, load address space back
from disk (swap in process)
-
-
-
-
-
-
-
-
-
-
-
-
-
Linux: swap partition
/etc/fstab
sudo fdisk -l
Windows: C:\swapfile.sys
$ sudo fdisk -l
Disk /dev/sda: 64 GiB, 68719476736 bytes, 134217728 sectors
Disk model: QEMU HARDDISK
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x2ae68c61
Device Boot Start End Sectors Size Id Type
/dev/sda1 * 2048 127299583 127297536 60.7G 83 Linux
/dev/sda2 127301630 134215679 6914050 3.3G f W95 Ext'd (LBA)
/dev/sda5 127301632 134215679 6914048 3.3G 82 Linux swap / Solaris
B
B
B
B
B
B
D
D
D
C
C
C
C
C
A
A
A
A
A
A
A
OS
OS
OS
OS
OS
OS
OS
disk
process D creation
process A ready
RAM
MOS Figure 3-4
B
B
B
C
C
C
D
D
A
A
A
OS
OS
OS
?
fragmentation
What can be done to resolve this?
Rearrange processes in memory
Why is this expensive?
What if a process needs more space?
What if a running process needs more space?
Pre-allocate extra room for process growth.
(dynamic allocation on stack or heap)
but how much room?
where should room for growth go?
what if the process still needs more memory?
tradeoffs between memory usage and out-of-memory risk
Reality looks quite different with paging and
ASLR
move process to larger gap, or swap out
process and wait for a larger gap to open up
B
B
A
heap
heap
stack
stack
A
OS
OS
room for
growth
room for
growth
MOS Figure 3-5
a lot of copying
swap
swap
if we have too many processes in RAM, for
a new one, we can make room by using disk.