operating systems - sm.luth.se · operating systems lecture 6 – memory management 2 memory...
TRANSCRIPT
1
Operating Systems
Lecture 6 – Memory management 2
Memory Management 2 – Overview
• Paging (contd.)– Structure of page table
– Shared memory
• Segmentation
• Segmentation with paging• Virtual memory
Paging...
• Just to remind you...– logical
address– page table
– physical address
2
Invalid bit in page table
• Pages not used by process– no corresponding
frame
– invalid bit set
– trap if addressed
Structure of the page table
• Page table can be large– spans the whole address space– Example: 4kb pages and 32 bit address space
• 2^(32-12)=2^20 entries in page table• if entry is 4 bytes (32 bits), table is 4MB
– 64 bits architechtures?• have to do something!
• Solutions– Page table length register– Hierachical page table– Hashed page table– Inverted page table
Hierarchical page table
• Divide logical address in several parts– outer table index– inner table index– offset (as usual)
• requires less space– invalid page of outer table
• no table at all for inner table
• requires more memory lookups– hardware support
p1 p2 d
logical address:
3
Hierarchical page table
• Several levels of hierarchy possible– SPARC support three levels– MC68030 support four levels
• Very large address space are still handled poorly– 64-bit addresses would require seven levels
Hashed page table
• table size– no direct relation to size of
address space• used for very large address
spaces
• Issues– collision in hash table– hash function
Inverted page table
• Regular page table– for each page in address space
• store frame number (map from pages to frames)
– very large table for large address spaces
• Logical address space larger than physical memory
• Inverted page table– for each fram in physical memory
• store page number (map from frames to pages)
– table size depend on amount of physical memory
4
Inverted page table
• Map frames to pages but...– we want to map pages to frames!
• how to do that?
• search the table in some way– hash table could be used to speed up search
• Only one table in the system– for all processes– same page present several times
• for different processes• include process id in table
• Used by several architechtures– UltraSPARC, PowerPC, ...
Inverted page table
• TLB searched first– then inverted
table
• Searching the inverted table is very slow– linear search
Shared memory
• Code can be shared between processes– several instances of the same program
– dynamic link library
– self-modifying code does not work!• should never be used anyway
– must appear in the same memory location in each process – why?
• program addresses becomes wrong otherwise
• Data can be shared– can appear anywhere in the address space
5
Shared memory on paged system
• Map pages from different processes to the same (shared) frame
• big problem with inverted page table– only one page entry per frame– let the mem ref. trap
• handle the mapping in kernel– slower
Segmentation
• User memory divided into segments– address specified as
<segment number, offset>
• Motivation– segments represent
semantically defined portions of user memory: code, data, stack,...
• segments can be defined ”read”, ”write”, ”execute”, just as pages
• Segments can be shared between processes
Segmentation architecture
• Address: <segment, offset>– the segment is often implicit
• set in a register in the cpu
• Each process has a segment table– one entry in table is:
• base: physical address of start of segment• limit: size of segment• works in the same way as contiguous memory allocation
• MMU– Segment-table base register (STBR)– Segment-table length register (STLR)
6
Segmentation example
• memory holes– same problem as
contiguous allocation
• several logical address spaces– one per segment
Segmentation hardware
• similar to contiguous allocation– use table instead
of register
• memory protection– segment size– flags
• read/write/execute...
Shared segments
• Share segments– code
• several instances of same program
• shared libraries
– data
7
Allocation of segments
• Segments can have different sizes– dynamic storage allocation problem
• search for holes, first fit, bestr fit, etc...
– external fragmentation
• Solution to this?– compaction?
• slow, but works – IBM OS/2 1.3 uses this scheme– not that slow though... ☺
– better solution?
Segmentation with paging
• Combine both segmentation and segmentation
• Segment table does not contain physical addresses– page numbers
• Paging scheme solves external fragmentation
• Needs hardware support• Best of two worlds?
Segmentation with paging – the i386
segmentation
2-level paging
8
Virtual memory – Overview
• Virtual memory – idea• Demand paging
– page fault– page replacement– page replacement algorithms
• Virtual memory considerations– memory over-allocation
• Working set model• Efficient process creation
– yes it has to do with virtual memory! ☺• Memory mapped files
Virtual memory• Separate logical memory from physical memory
– earlier, we separated logical addresses from physical, now we separate the actual memory
• Only part of process need to be in physical memory– transparent to the process
• Emulate more memory than is present– use secondary storage– performance is decrease if used carelessly– performance is increased if used wisley
• better resource utilization
• Allows processes to share files efficiently• More efficient process creation• Implementation
– demand paging– demand segmentation
Idea of virtual memory
• Use disk as memory
• Transparent for user process
• load back into memory as needed
9
Demand paging
• Paging with swapping– entire process is swapped in/out of memory– process needs to be completely in memory in order to run– swapper module swaps processes in/out
• Demand paging– individuasl pages are moved to/from secondary storage as
needed– only small part (working set) of process needs to be in
memory– pager module moves pages to/from secondary storage
• reference to page not in memory traps to pager module
Demand paging
• Page table includes invalid bit– indicates page not
present• either page not used by
process (as previously) or...
• page not presently in physical memory
– needs to be loaded if needed
Page fault
• Acess to page marked invalid is called a page fault– trap to kernel
• Actions taken by kernel on page fault– decide if access is invalid or if page not in memory– choose an empty frame (if there are any)– load page from disk into the empty frame– update page table and TLB and set valid-bit to 1– restart instruction that caused the fault
10
Demand paging
Demand paging
• Hardware must be able to restart instruction– not as easy as it might look
– complex instructions might write to a valid page and then to an invalid page
• what to do with the completed write?
• Pure demand paging– only bring requested pages into memory– process started with zero pages in memory and
immediately faults
Performance of demand paging
• Costly to service page fault– I/O is slow
• memory access time: 10 to 200 ns• disk access time 10ms
• Disk is a factor of 10^6 slower than memory– when it comes to access time
• Few page faults crucial
• Efficient swap space handling crucial– swap space often handled separate from file systems
• increase performance a bit
11
No free frames – Page replacement
• No free frames– some frame needs to be replaced– page replacement algorithm
• select page to be replaced
• Pages needs to be saved (paged out)– before replaced by new pages– is page not changed since load
• discard without save
• page table contains dirty bit– maintained by hardware
• set on page write
– reduce i/o overhead• only dirty pages are paged out
Basic page replacement strategy
• Find location of desired page on disk
• Find free frame– if exists – use it– in not
• find a victim frame (page replacement algo)
• write out the victim fram to disk, if dirty
• Read desired page into free frame
• Restart process
Page replacement
11001
10010
pages valid
p1
p1
11001
dirtyframe
11010
access
RAM (frames):
swap space:
12
Page replacement algorithms
• What page to replace?• Page replacement algo should give lowest
page fault rate• Algorithm evaluation
– run on a sequence of memory references– compute number of page faults for that sequence
• Reference sequence– generated using some distribution– traces of actual memory references
Page replacement algorithms
• FIFO
• Optimal• LRU
• Counting algorithms
• Second chance– enhanced second chance
• Page buffering
Next lecture...
• More on virtual memory– page replacement algorithms
– process allocation– memory mapped files
– memory over-allocation