Operating Systems Part IV: Memory Management. Main Memory Large array of words or bytes each having its own address Several processes must be kept in.
Post on 01-Apr-2015
220 Views
Preview:
Transcript
Operating Systems
Part IV: Memory Management
Main Memory
Large array of words or bytes each having its own address
Several processes must be kept in main memory to improve utilization and system response: memory sharing
Memory management algorithms vary from simple approach to paging and segmentation strategies
Memory Basics
Types of memory addresses– Symbolic (e.g. program variables)– Relocatable (e.g. offset + 100)– Absolute (e.g. 255)
Address binding: Which data goes where. May be determined in any of the following phases– Compile time: compiler generates absolute code for
execution in a fixed address– Load time: compiler generates relocatable code, link-
loader computes relocation addresses during link time– Execution time: allows executing processes to move, by
simply changing values of segment registers.
Logical & Physical Addresses
Logical or virtual address – address generated by the CPU.
Physical address – address loaded into the memory-address register of RAM– Compile-time and load-time binding generate
identical logical and physical addresses– Execution-time binding generate differing logical
and physical addresses– Memory management unit – maps virtual to
physical addresses during runtime.
Improving Memory Utilization
Dynamic loading– Subroutines are stored on disk in relocatable format, and
are not loaded until called Dynamic linking
– Linking to subroutine libraries postponed until run-time; stub used as pointer to routine in a shared DLL.
– Conserves disk space – a single copy of library is shared by all executing processes. Versioning issue.
Overlays– Keeps only needed instructions in memory– Other instructions overwrite previously occupied address
when needed. May be implemented by programmer.
Swapping
Used if memory is no longer sufficient
The roll out (swap out to disk) and roll in (swap to MM) drastically increases time for context switch
Swapping
Needs a fast backing store (secondary memory) for efficient implementation
Waiting processes are good candidates to be swapped out to disk
Processes waiting on I/O should not be swapped out, since the I/O could be into their address space, or I/O should be done into OS buffers only.
Swapping
Modified version of swapping used in Unix. Swapping normally disabled. Enabled when memory runs out due to many running processes.In Linux, only R/W data segment needs to be swapped out, R/O code segment are just overwritten, since it can be reread from disk.
Microsoft Windows provides partial swapping - if not enough memory for a new program, current program is swapped out to disk. User determines swap rather than scheduler
Memory Protection
OS must protect itself from user processes, and must protect user processes from each other.
Each process is assigned a relocation register and a limit register.
Relocation register contains the value of the smallest physical address.
Logical address must be less than the limit register
How memory protection works
Contiguous Allocation
Type of allocation where each process occupies only a single continuous block in main memory
Simple two-partition scheme– Low memory: usually contains resident O/S
since interrupt vectors are here– Rest of memory: for user processes
Contiguous Allocation
Multiple-Partition Algorithm– Simplest is multiple fixed partition
Each partition is allocated to a processMultiprogramming limited to number of partitions
– Dynamic partitioningStarts with one large memory block called a “hole”Processes arrive and are allocated a blockHoles become available as processes terminate
Contiguous Allocation
Multiple-Partition Algorithm– Dynamic Partitioning (cont’d)
OS
process 5
process 8
process 2
OS
process 5
process 2
OS
process 5
process 2
OS
process 5
process 9
process 2
process 9
process 10
Contiguous Allocation
Dynamic storage allocation problem– looking for freed memory for waiting processes– set of holes searched to see w/c one to allocate
first-fit - allocate first hole big enough for process (search may start from beginning or end)
best-fit - allocate smallest hole that is big enough worst-fit - allocate largest hole -> produces largest leftover
(sometimes useful than smaller ones)
– first/best better in time/storage utilization, respectively– first-fit is generally faster
Contiguous Allocation
Fragmentation– External
Enough memory exists but not contiguous 50% rule - given N allocated blocks, the next 0.5N blocks will
be lost due to fragmentation (1/3 is unusable) when first-fit is used.
– Internal Allocate memory in fixed-sized units, say 4k blocks. Memory
actually allocated to a process may be slightly larger than requested memory. The difference is internal fragmentation.
Contiguous Allocation
Compaction– A solution to external fragmentation – shuffle memory contents
to place all free memory together in one large block.– Not always possible if relocatable addressing at execution time
is not supported– Algorithm 1: move processes to one end (expensive if many
processes are moved)– Algorithm 2: create big hole in the middle– Swapping may be combined w/ compaction
processes rolled out to backing store then back in– compaction not possible w/ disk due to slow access
Paging
Allows non-contiguous allocation -> solves external fragmentation
Logical memory– Fixed sized blocks called pages
Physical memory– Fixed-sized blocks called frames
Page table converts pages to frames, using address translation hardware– page# + offset -> frame# + offset, using page table
Backing store (swap partition in Linux)– same structure as logical memory
Paging Examples
Internal Fragmentation in Paging
External fragmentation is eliminated but internal fragmentation is not since processes rarely take up all the memory space allocated to them
Worst case:– Process needs (n pages + 1 byte)– Wasted space of (page size bytes – 1 byte)
Page Table Structure
Each O/S has own method for storing page tables -> most allocate a page table per process
Context-switch time increases with paging due to need to store page tables in PCB of each process
Each page table entry might include access type as r/o (constant data), r/w (variable data), or x/o (code), to implement a further level of memory protection
Page table structure: linear, multilevel hierarchical, hashed, inverted.
Shared Pages
Shared read-only/execute-only code– When several instances of a single program are
running, only one copy of the program code is stored in memory, but each instance has its own program data. Code must be reentrant.
Possibility of sharing common code is another advantage of paging
Similar to sharing of address space of a task by threads.
Shared Pages: An Example
Segmentation
Scheme divides logical memory into segments
More intuitive view of memory from user’s point of view (e.g. program divided into segments -- subroutines, procedures, data -- that have different length)
Logical View of Segmentation
1
3
2
4
1
4
2
3
user space physical memory space
Segmentation Hardware
Logical (2-dimensional) vs. physical (1-dimensional) -> mapping effected through a segment table
Entry consists of segment base (=starting address in physical memory) and limit (= length of segment)
Similar to concept of pages except segments do not have fixed length
Intel 80x86 is based on segmentation
Mapping Segments to Physical Memory
Segments and Fragmentation
Segmentation may cause external fragmentation
Happens when all free blocks are too small to accommodate a segment
Compaction may be used to solve the problem
Process may wait if segment cannot be found
Segmentation with Paging
Solves the external fragmentation problem of pure segmentation
Each segment is composed of several equal-sized pages
top related