5/22 5/13 OS作業

5/13 OS作業
1. Give the methods that are used in page table and TLB for searching the accessing pages. Compare the differences on the searches between these two hardwares and give reasons why TLB will help the search of the pages.
Page table:
Address generated by CPU is divided into:
(1) Page number (p): used as an index into a page table which contains base address of each page in physical memory.
(2) Page offset (d): combined with base address to define the physical memory address that is sent to the memory unit.
When presented with an item, it is compared with all keys simultaneously.
If the page number is found in the TLB, its frame number is immediately available and used to access memory.
If the page number is not in the TLB, a memory reference to the page table must be made.
The differences between page table and TLB are that page table can directly find physical address through the page number while TLB uses the method which compared with all page numbers simultaneously.
If the page number is not in the TLB, and it will go to page table. Because page table is in the main memory, we should use TLB to avoid taking much time to search.
2. What is the purpose of paging the page table?
In certain situations the page tables could become large enough that by paging the page tables, one could simplify the memory allocation problem (by ensuring that everything is allocated as fixed-size pages as opposed to variable-sized chunks) and also enable the swapping of portions of page table that are not currently used.
3. Consider a 32bit address space with 2K bytes page size, assuming that each entry consists of 4 bytes, how much memory are required for the page table for each process? Explain your reason.

The size of each page is 2K (2^11 bytes).
Total number of pages is 2^32/2^11=2^21 pages.
Since each entry is 4 bytes, we require 4x2^21 = 2^23 bytes = 8 MB to hold this table.
4. Compare the main memory organization schemes of contiguous-memory allocation, pure segmentation, and pure paging with respect to the following issues:
a. external fragmentation
b. internal fragmentation
c. ability to share code across processes
a. external fragmentation is a contiguous allocation with fixed size partions that does not suffer from external fragmentation, but contiguous allocation with variable sized partitions does. Pure paging does not suffer from external fragmentation, since partitions and pages are fixed in size. Segmentation does suffer from external fragmentation.
b. internal fragmentation segmentation and variable-sized partitions do not suffer from internal fragmentation, since by definition, a segment/partition is exactly as large as it needs to be. However, contiguous allocation with fixed-size partitions and paging both may suffer from internal fragmentation when partitions and pages are not completely filled.
c. ability to share code across processes is a contiguous allocation provides no support for code sharing. In segmentation, as long as the segments of a process do not mix text and data, we can easily share code between processes. We simply adjust the segment tables of each process to point to the same segment of code in memory. For security reasons, however, it would probably be desirable to have some method of preventing processes from modifying code, since doing so would allow one process to change the code executed by another. In pure paging, code can be shared across processes simply by sharing page frames. To do this, adjust the page tables of the two processes so that their different logical pages map to the same physical page frame. However, we do need to make certain that no page frame contains any data, which should not be shared. We could accomplish this by, for example, padding the last page of the text segment of the process with no-op machine language instructions.