132 lines
5.7 KiB
Markdown
132 lines
5.7 KiB
Markdown
|
|
In this homework, you will use a simple program, which is known as
|
|
paging-linear-translate.py, to see if you understand how simple
|
|
virtual-to-physical address translation works with linear page tables. To run
|
|
the program, remember to either type just the name of the program
|
|
(./paging-linear-translate.py) or possibly this (python
|
|
paging-linear-translate.py). When you run it with the -h (help) flag, you
|
|
see:
|
|
|
|
Usage: paging-linear-translate.py [options]
|
|
|
|
Options:
|
|
-h, --help show this help message and exit
|
|
-s SEED, --seed=SEED the random seed
|
|
-a ASIZE, --asize=ASIZE
|
|
address space size (e.g., 16, 64k, ...)
|
|
-p PSIZE, --physmem=PSIZE
|
|
physical memory size (e.g., 16, 64k, ...)
|
|
-P PAGESIZE, --pagesize=PAGESIZE
|
|
page size (e.g., 4k, 8k, ...)
|
|
-n NUM, --addresses=NUM number of virtual addresses to generate
|
|
-u USED, --used=USED percent of address space that is used
|
|
-v verbose mode
|
|
-c compute answers for me
|
|
|
|
First, run the program without any arguments:
|
|
|
|
ARG seed 0
|
|
ARG address space size 16k
|
|
ARG phys mem size 64k
|
|
ARG page size 4k
|
|
ARG verbose False
|
|
|
|
The format of the page table is simple:
|
|
The high-order (left-most) bit is the VALID bit.
|
|
If the bit is 1, the rest of the entry is the PFN.
|
|
If the bit is 0, the page is not valid.
|
|
Use verbose mode (-v) if you want to print the VPN # by
|
|
each entry of the page table.
|
|
|
|
Page Table (from entry 0 down to the max size)
|
|
0x8000000c
|
|
0x00000000
|
|
0x00000000
|
|
0x80000006
|
|
|
|
Virtual Address Trace
|
|
VA 0: 0x00003229 (decimal: 12841) --> PA or invalid?
|
|
VA 1: 0x00001369 (decimal: 4969) --> PA or invalid?
|
|
VA 2: 0x00001e80 (decimal: 7808) --> PA or invalid?
|
|
VA 3: 0x00002556 (decimal: 9558) --> PA or invalid?
|
|
VA 4: 0x00003a1e (decimal: 14878) --> PA or invalid?
|
|
|
|
For each virtual address, write down the physical address it
|
|
translates to OR write down that it is an out-of-bounds
|
|
address (e.g., a segmentation fault).
|
|
|
|
As you can see, what the program provides for you is a page table for a
|
|
particular process (remember, in a real system with linear page tables, there
|
|
is one page table per process; here we just focus on one process, its address
|
|
space, and thus a single page table). The page table tells you, for each
|
|
virtual page number (VPN) of the address space, that the virtual page is
|
|
mapped to a particular physical frame number (PFN) and thus valid, or not
|
|
valid.
|
|
|
|
The format of the page-table entry is simple: the left-most (high-order) bit
|
|
is the valid bit; the remaining bits, if valid is 1, is the PFN.
|
|
|
|
In the example above, the page table maps VPN 0 to PFN 0xc (decimal 12), VPN 3
|
|
to PFN 0x6 (decimal 6), and leaves the other two virtual pages, 1 and 2, as
|
|
not valid.
|
|
|
|
Because the page table is a linear array, what is printed above is a replica
|
|
of what you would see in memory if you looked at the bits yourself. However,
|
|
it is sometimes easier to use this simulator if you run with the verbose flag
|
|
(-v); this flag also prints out the VPN (index) into the page table. From the
|
|
example above, run with the -v flag:
|
|
|
|
Page Table (from entry 0 down to the max size)
|
|
[ 0] 0x8000000c
|
|
[ 1] 0x00000000
|
|
[ 2] 0x00000000
|
|
[ 3] 0x80000006
|
|
|
|
Your job, then, is to use this page table to translate the virtual addresses
|
|
given to you in the trace to physical addresses. Let's look at the first one:
|
|
VA 0x3229. To translate this virtual address into a physical address, we first
|
|
have to break it up into its constituent components: a virtual page number and
|
|
an offset. We do this by noting down the size of the address space and the
|
|
page size. In this example, the address space is set to 16KB (a very small
|
|
address space) and the page size is 4KB. Thus, we know that there are 14 bits
|
|
in the virtual address, and that the offset is 12 bits, leaving 2 bits for the
|
|
VPN. Thus, with our address 0x3229, which is binary 11 0010 0010 1001, we know
|
|
the top two bits specify the VPN. Thus, 0x3229 is on virtual page 3 with an
|
|
offset of 0x229.
|
|
|
|
We next look in the page table to see if VPN 3 is valid and mapped to some
|
|
physical frame or invalid, and we see that it is indeed valid (the high bit is
|
|
1) and mapped to physical page 6. Thus, we can form our final physical address
|
|
by taking the physical page 6 and adding it onto the offset, as follows:
|
|
0x6000 (the physical page, shifted into the proper spot) OR 0x0229 (the
|
|
offset), yielding the final physical address: 0x6229. Thus, we can see that
|
|
virtual address 0x3229 translates to physical address 0x6229 in this example.
|
|
|
|
To see the rest of the solutions (after you have computed them yourself!),
|
|
just run with the -c flag (as always):
|
|
|
|
...
|
|
VA 0: 00003229 (decimal: 12841) --> 00006229 (25129) [VPN 3]
|
|
VA 1: 00001369 (decimal: 4969) --> Invalid (VPN 1 not valid)
|
|
VA 2: 00001e80 (decimal: 7808) --> Invalid (VPN 1 not valid)
|
|
VA 3: 00002556 (decimal: 9558) --> Invalid (VPN 2 not valid)
|
|
VA 4: 00003a1e (decimal: 14878) --> 00006a1e (27166) [VPN 3]
|
|
|
|
Of course, you can change many of these parameters to make more interesting
|
|
problems. Run the program with the -h flag to see what options there are:
|
|
|
|
- The -s flag changes the random seed and thus generates different
|
|
page table values as well as different virtual addresses to translate.
|
|
- The -a flag changes the size of the address space.
|
|
- The -p flag changes the size of physical memory.
|
|
- The -P flag changes the size of a page.
|
|
- The -n flag can be used to generate more addresses to translate
|
|
(instead of the default 5).
|
|
- The -u flag changes the fraction of mappings that are valid, from
|
|
0% (-u 0) up to 100% (-u 100). The default is 50, which means
|
|
that roughly 1/2 of the pages in the virtual address space will be valid.
|
|
- The -v flag prints out the VPN numbers to make your life easier.
|
|
|
|
|
|
|