Update master from bsys-ws17-template/hw3

files/hw3.txt

@@ -0,0 +1,22 @@
+./hw3/README.md
+
+./hw3/simu1/QUESTIONS.md
+./hw3/simu1/README-relocation.md
+./hw3/simu1/relocation.py
+./hw3/simu1/ANSWERS.md
+
+./hw3/simu2/QUESTIONS.md
+./hw3/simu2/README-segmentation.md
+./hw3/simu2/segmentation.py
+./hw3/simu2/ANSWERS.md
+
+./hw3/simu3/QUESTIONS.md
+./hw3/simu3/README-malloc.md
+./hw3/simu3/malloc.py
+./hw3/simu3/ANSWERS.md
+
+./hw3/simu4/QUESTIONS.md
+./hw3/simu4/README-paging-linear-translate.md
+./hw3/simu4/paging-linear-translate.py
+./hw3/simu4/ANSWERS.md
+

hw3/README.md

@@ -0,0 +1,51 @@
+# hw3
+
+## Tasks
+
+To fulfill **hw3** you have to solve:
+
+- simu1
+- simu2
+- simu3
+- simu4
+
+## ASIDE: SIMULATION HOMEWORKS
+
+Simulation homeworks (`simuN/`) come in the form of simulators you run to make
+sure you understand some piece of the material. The simulators are generally
+python programs that enable you both to generate different problems (using
+different random seeds) as well as to have the program solve the problem for you
+(with the `-c` flag) so that you can check your answers. Running any simulator
+with a `-h` or `--help`flag will provide with more information as to all the
+options the simulator gives you.
+
+The README provided with each simulator gives more detail as to how to run it.
+Each flag is described in some detail therein.
+
+You find all Files for your simulation homework in the `simuN/` directory.
+
+**IMPORTANT**: This time, there is no possibility to give more
+explanations/comments  AFTER the Code Review. You have to give all the asked
+explanations and comments (in German or English) before the code review.
+
+The code review starts after the deadline, so you have enough time to extend
+your answers, if your Pull-Request was quite early. After the deadline there
+will be no review process (as you already now). This time the review helps you
+to only correct your answers in cases, where you solved a problem in a wrong
+way.
+
+## Pull-Request
+
+Please merge any accepted reviews into your branch. If you are ready with the
+homework, all tests run, please create a pull request named **hw3**.
+
+## Credits for hw3
+
+| Task     | max. Credits | Comment |
+| -------- | ------------ | ------- |
+| simu1    | 1            |         |
+| simu2    | 1            |         |
+| simu3    | 1            |         |
+| simu4    | 1            |         |
+| Deadline | +1           |         |
+| =        | 5            |         |

hw3/simu1/QUESTIONS.md

@@ -0,0 +1,53 @@
+# Questions 15-Relocation
+
+The program `relocation.py` allows you to see how address translations are
+performed in a system with base and bounds registers. See the `README` for
+details.
+
+## Warmup
+
+Run with seeds 1, 2, and 3, and compute whether each virtual address generated
+by the process is in or out of bounds. If in bounds, compute the translation.
+
+Please answer the questions, by giving the result and - if asked - an
+explanation, why you got the result. Write your answers in markdown syntax in
+the new file `ANSWERS.md.`
+
+## Questions
+
+1. Run with these flags: `-s 0 -n 10`. What value do you have set `-l` (the
+   bounds register) to in order to ensure that all the generated virtual
+   addresses are within bounds?
+
+1. Run with these flags: `-s 1 -n 10 -l 100`. What is the maximum value that
+   base can be set to, such that the address space still fits into physical
+   memory in its entirety (explanation)?
+
+1. Run some of the same problems above, but with larger address spaces (-a) and
+   physical memories (-p). How does increasing effect the results (explanation)?
+
+1. For each virtual address, either write down the physical address it
+   translates to OR write down that it is an out-of-bounds address (a
+   segmentation violation). For this problem, you should assume a simple virtual
+   address space of a given size.
+
+   ```text
+   ARG phys mem size 16k
+
+   Base-and-Bounds register information:
+
+     Base   : 0x00003952 (decimal 14674)
+     Limit  : 1024
+
+   Virtual Address Trace
+     VA  0: 0x0000024c (decimal:  588) --> PA or segmentation violation?
+     VA  1: 0x000004eb (decimal: 1259) --> PA or segmentation violation?
+     VA  2: 0x000002bd (decimal:  701) --> PA or segmentation violation?
+     VA  3: 0x000000fa (decimal:  250) --> PA or segmentation violation?
+     VA  4: 0x00000486 (decimal: 1158) --> PA or segmentation violation?
+     VA  5: 0x00000521 (decimal: 1313) --> PA or segmentation violation?
+     VA  6: 0x0000065c (decimal: 1628) --> PA or segmentation violation?
+     VA  7: 0x000001a3 (decimal:  419) --> PA or segmentation violation?
+     VA  8: 0x0000063a (decimal: 1594) --> PA or segmentation violation?
+     VA  9: 0x0000034d (decimal:  845) --> PA or segmentation violation?
+    ```

hw3/simu1/README-relocation.md

@@ -0,0 +1,99 @@
+# README Relocation
+
+This program allows you to see how address translations are performed in a
+system with base and bounds registers. As before, there are two steps to running
+the program to test out your understanding of base and bounds. First, run
+without the -c flag to generate a set of translations and see if you can
+correctly perform the address translations yourself. Then, when done, run with
+the -c flag to check your answers.
+
+In this homework, we will assume a slightly different address space than our
+canonical one with a heap and stack at opposite ends of the space. Rather, we
+will assume that the address space has a code section, then a fixed-sized
+(small) stack, and a heap that grows downward right after, looking something
+like you see in the Figure below. In this configuration, there is only one
+direction of growth, towards higher regions of the address space.
+
+```text
+  -------------- 0KB
+  |    Code    |
+  -------------- 2KB
+  |   Stack    |
+  -------------- 4KB
+  |    Heap    |
+  |     |      |
+  |     v      |
+  -------------- 7KB
+  |   (free)   |
+  |     ...    |
+```
+
+In the figure, the bounds register would be set to 7~KB, as that represents the
+end of the address space. References to any address within the bounds would be
+considered legal; references above this value are out of bounds and thus the
+hardware would raise an exception.
+
+To run with the default flags, type **relocation.py** at the command line. The
+result should be something like this:
+
+```text
+prompt> ./relocation.py
+...
+Base-and-Bounds register information:
+
+  Base   : 0x00003082 (decimal 12418)
+  Limit  : 472
+
+Virtual Address Trace
+  VA  0: 0x01ae (decimal:430) -> PA or violation?
+  VA  1: 0x0109 (decimal:265) -> PA or violation?
+  VA  2: 0x020b (decimal:523) -> PA or violation?
+  VA  3: 0x019e (decimal:414) -> PA or violation?
+  VA  4: 0x0322 (decimal:802) -> PA or violation?
+
+For each virtual address, either write down the physical address it
+translates to OR write down that it is an out-of-bounds address
+(a segmentation violation). For this problem, you should assume a
+simple virtual address space of a given size.
+```
+
+As you can see, the homework simply generates randomized virtual
+addresses. For each, you should determine whether it is in bounds, and if so,
+determine to which physical address it translates. Running with -c (the
+"compute this for me" flag) gives us the results of these translations, i.e.,
+whether they are valid or not, and if valid, the resulting physical
+addresses. For convenience, all numbers are given both in hex and decimal.
+
+```text
+prompt> ./relocation.py -c
+...
+Virtual Address Trace VA  0: 0x01ae (decimal:430) -> VALID: 0x00003230
+  (dec:12848) VA  1: 0x0109 (decimal:265) -> VALID: 0x0000318b (dec:12683) VA
+  2: 0x020b (decimal:523) -> SEGMENTATION VIOLATION VA  3: 0x019e (decimal:414)
+  -> VALID: 0x00003220 (dec:12832) VA  4: 0x0322 (decimal:802) -> SEGMENTATION
+  VIOLATION
+```
+
+With a base address of 12418 (decimal), address 430 is within bounds (i.e., it
+is less than the limit register of 472) and thus translates to 430 added to
+12418 or 12848. A few of the addresses shown above are out of bounds (523,
+802), as they are in excess of the bounds. Pretty simple, no? Indeed, that is
+one of the beauties of base and bounds: it's so darn simple!
+
+There are a few flags you can use to control what's going on better:
+
+```text
+prompt> ./relocation.py -h Usage: relocation.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, 32m) -p PSIZE, --physmem=PSIZE physical memory size (e.g., 16, 64k)
+  -n NUM, --addresses=NUM # of virtual addresses to generate -b BASE, --b=BASE
+  value of base register -l LIMIT, --l=LIMIT   value of limit register -c,
+  --compute         compute answers for me
+```
+
+In particular, you can control the virtual address-space size (-a), the size
+of physical memory (-p), the number of virtual addresses to generate (-n), and
+the values of the base and bounds registers for this process (-b and -l,
+respectively).

hw3/simu1/relocation.py

@@ -0,0 +1,118 @@
+#! /usr/bin/env python
+
+import sys
+from optparse import OptionParser
+import random
+import math
+
+def convert(size):
+    length = len(size)
+    lastchar = size[length-1]
+    if (lastchar == 'k') or (lastchar == 'K'):
+        m = 1024
+        nsize = int(size[0:length-1]) * m
+    elif (lastchar == 'm') or (lastchar == 'M'):
+        m = 1024*1024
+        nsize = int(size[0:length-1]) * m
+    elif (lastchar == 'g') or (lastchar == 'G'):
+        m = 1024*1024*1024
+        nsize = int(size[0:length-1]) * m
+    else:
+        nsize = int(size)
+    return nsize
+
+
+#
+# main program
+#
+parser = OptionParser()
+parser.add_option('-s', '--seed',      default=0,     help='the random seed',                                action='store', type='int', dest='seed')
+parser.add_option('-a', '--asize',     default='1k',  help='address space size (e.g., 16, 64k, 32m, 1g)',    action='store', type='string', dest='asize')
+parser.add_option('-p', '--physmem',   default='16k', help='physical memory size (e.g., 16, 64k, 32m, 1g)',  action='store', type='string', dest='psize')
+parser.add_option('-n', '--addresses', default=5,     help='number of virtual addresses to generate',        action='store', type='int', dest='num')
+parser.add_option('-b', '--b',         default='-1',  help='value of base register',                         action='store', type='string', dest='base')
+parser.add_option('-l', '--l',         default='-1',  help='value of limit register',                        action='store', type='string', dest='limit')
+parser.add_option('-c', '--compute',   default=False, help='compute answers for me',                         action='store_true', dest='solve')
+
+
+(options, args) = parser.parse_args()
+
+print ''
+print 'ARG seed', options.seed
+print 'ARG address space size', options.asize
+print 'ARG phys mem size', options.psize
+print ''
+
+random.seed(options.seed)
+asize = convert(options.asize)
+psize = convert(options.psize)
+
+if psize <= 1:
+    print 'Error: must specify a non-zero physical memory size.'
+    exit(1)
+
+if asize == 0:
+    print 'Error: must specify a non-zero address-space size.'
+    exit(1)
+
+if psize <= asize:
+    print 'Error: physical memory size must be GREATER than address space size (for this simulation)'
+    exit(1)
+
+#
+# need to generate base, bounds for segment registers
+#
+limit = convert(options.limit)
+base  = convert(options.base)
+
+if limit == -1:
+    limit = int(asize/4.0 + (asize/4.0 * random.random()))
+
+# now have to find room for them
+if base == -1:
+    done = 0
+    while done == 0:
+        base = int(psize * random.random())
+        if (base + limit) < psize:
+            done = 1
+
+print 'Base-and-Bounds register information:'
+print ''
+print '  Base   : 0x%08x (decimal %d)' % (base, base)
+print '  Limit  : %d' % (limit)
+print ''
+
+if base + limit > psize:
+    print 'Error: address space does not fit into physical memory with those base/bounds values.'
+    print 'Base + Limit:', base + limit, '  Psize:', psize
+    exit(1)
+
+#
+# now, need to generate virtual address trace
+#
+print 'Virtual Address Trace'
+for i in range(0,options.num):
+    vaddr = int(asize * random.random())
+    if options.solve == False:
+        print '  VA %2d: 0x%08x (decimal: %4d) --> PA or segmentation violation?' % (i, vaddr, vaddr)
+    else:
+        paddr = 0
+        if (vaddr >= limit):
+            print '  VA %2d: 0x%08x (decimal: %4d) --> SEGMENTATION VIOLATION' % (i, vaddr, vaddr)
+        else:
+            paddr = vaddr + base
+            print '  VA %2d: 0x%08x (decimal: %4d) --> VALID: 0x%08x (decimal: %4d)' % (i, vaddr, vaddr, paddr, paddr)
+
+
+print ''
+
+if options.solve == False:
+    print 'For each virtual address, either write down the physical address it translates to'
+    print 'OR write down that it is an out-of-bounds address (a segmentation violation). For'
+    print 'this problem, you should assume a simple virtual address space of a given size.'
+    print ''
+
+
+
+
+

hw3/simu2/QUESTIONS.md

@@ -0,0 +1,87 @@
+# Questions 16-Segmentation
+
+This program allows you to see how address translations are performed in a
+system with segmentation. See the `README` for details.
+
+## Warm-up
+
+First let’s use a tiny address space to translate some addresses. Here’s a
+simple set of parameters with a few different random seeds; can you translate
+the addresses?
+
+```text
+      segmentation.py -a 128 -p 512 -b 0 -l 20 -B 512 -L 20 -s 0
+      segmentation.py -a 128 -p 512 -b 0 -l 20 -B 512 -L 20 -s 1
+      segmentation.py -a 128 -p 512 -b 0 -l 20 -B 512 -L 20 -s 2
+```
+
+## Questions
+
+1. Now, let’s see if we understand this tiny address space we’ve constructed
+   (using the parameters from the warm-up above). What is the highest legal
+   virtual address in segment 0? What about the lowest legal virtual address in
+   segment 1? What are the lowest and highest illegal addresses in this entire
+   address space? Finally, how would you run segmentation.py with the -A flag to
+   test if you are right?
+
+1. Let’s say we have a tiny 16-byte address space in a 128-byte physical memory.
+   What base and bounds would you set up so as to get the simulator to generate
+   the following translation results for the specified address stream: valid,
+   valid, violation, ..., violation, valid, valid? Assume the following
+   parameters:
+
+   ```text
+     segmentation.py -a 16 -p 128
+         -A 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
+         --b0 ? --l0 ? --b1 ? --l1 ?
+   ```
+
+1. Assuming we want to generate a problem where roughly 90% of the
+   randomly-generated virtual addresses are valid (i.e., not segmentation
+   violations). How should you configure the simulator to do so? Which
+   parameters are important (Explanation!)?
+
+1. Can you run the simulator such that no virtual addresses are valid? How
+   (Explanation)?
+
+1. For each virtual address, either write down the physical address (hex and
+   decimal) it translates to OR write down that it is an out-of-bounds address
+   (a segmentation violation). For this problem, you should assume a simple
+   address space with two segments: the top bit of the virtual address can thus
+   be used to check whether the virtual address is in segment 0 (topbit=0) or
+   segment 1 (topbit=1). Note that the base/limit pairs given to you grow in
+   different directions, depending on the segment, i.e., segment 0 grows in the
+   positive direction, whereas segment 1 in the negative.
+
+   ```text
+   ARG address space size 364
+   ARG phys mem size 756
+
+   Segment register information:
+
+     Segment 0 base  (grows positive) : 0x00000000 (decimal 0)
+     Segment 0 limit                  : 64
+
+     Segment 1 base  (grows negative) : 0x00000400 (decimal 1024)
+     Segment 1 limit                  : 128
+
+   Virtual Address Trace
+     VA  0: 0x0000005c (decimal:   92) --> PA or segmentation violation?
+     VA  1: 0x00000011 (decimal:   17) --> PA or segmentation violation?
+     VA  2: 0x00000043 (decimal:   67) --> PA or segmentation violation?
+     VA  3: 0x00000021 (decimal:   33) --> PA or segmentation violation?
+     VA  4: 0x0000006c (decimal:  108) --> PA or segmentation violation?
+     VA  5: 0x0000007a (decimal:  122) --> PA or segmentation violation?
+     VA  6: 0x00000050 (decimal:   80) --> PA or segmentation violation?
+     VA  7: 0x00000037 (decimal:   55) --> PA or segmentation violation?
+     VA  8: 0x000000ff (decimal:  255) --> PA or segmentation violation?
+     VA  9: 0x000000e9 (decimal:  233) --> PA or segmentation violation?
+     VA 10: 0x00000001 (decimal:    1) --> PA or segmentation violation?
+     VA 11: 0x0000014c (decimal:  332) --> PA or segmentation violation?
+     VA 12: 0x000000b4 (decimal:  180) --> PA or segmentation violation?
+     VA 13: 0x000000cf (decimal:  207) --> PA or segmentation violation?
+     VA 14: 0x0000012b (decimal:  299) --> PA or segmentation violation?
+     VA 15: 0x00000084 (decimal:  132) --> PA or segmentation violation?
+   ```
+
+   How did you solve this question?

hw3/simu2/README-segmentation.md

@@ -0,0 +1,183 @@
+# README Segmentation
+
+This program allows you to see how address translations are performed in a
+system with segmentation. The segmentation that this system uses is pretty
+simple: an address space has just *two* segments; further, the top bit of the
+virtual address generated by the process determines which segment the address is
+in: 0 for segment 0 (where, say, code and the heap would reside) and 1 for
+segment 1 (where the stack lives). Segment 0 grows in a positive direction
+(towards higher addresses), whereas segment 1 grows in the negative direction.
+
+Visually, the address space looks like this:
+
+```text
+ --------------- virtual address 0
+ |    seg0     |
+ |             |
+ |             |
+ |-------------|
+ |             |
+ |             |
+ |             |
+ |             |
+ |(unallocated)|
+ |             |
+ |             |
+ |             |
+ |-------------|
+ |             |
+ |    seg1     |
+ |-------------| virtual address max (size of address space)
+```
+
+With segmentation, as you might recall, there is a base/limit pair of registers
+per segment. Thus, in this problem, there are two base/limit pairs. The
+segment-0 base tells which physical address the *top* of segment 0 has been
+placed in physical memory and the limit tells how big the segment is; the
+segment-1 base tells where the *bottom* of segment 1 has been placed in physical
+memory and the corresponding limit also tells us how big the segment is (or how
+far it grows in the negative direction).
+
+As in `relocation (simu1)`, there are two steps to running the program to test
+out your understanding of segmentation. First, run without the "-c" flag to
+generate a set of translations and see if you can correctly perform the address
+translations yourself. Then, when done, run with the "-c" flag to check your
+answers.
+
+For example, to run with the default flags, type:
+
+```text
+prompt> ./segmentation.py
+```
+
+or
+
+```text
+prompt> python ./segmentation.py
+```
+
+(if the first doesn't work)
+
+You should see this:
+
+```text
+  ARG seed 0
+  ARG address space size 1k
+  ARG phys mem size 16k
+
+  Segment register information:
+
+    Segment 0 base  (grows positive) : 0x00001aea (decimal 6890)
+    Segment 0 limit                  : 472
+
+    Segment 1 base  (grows negative) : 0x00001254 (decimal 4692)
+    Segment 1 limit                  : 450
+
+  Virtual Address Trace
+    VA  0: 0x0000020b (decimal:  523) --> PA or segmentation violation?
+    VA  1: 0x0000019e (decimal:  414) --> PA or segmentation violation?
+    VA  2: 0x00000322 (decimal:  802) --> PA or segmentation violation?
+    VA  3: 0x00000136 (decimal:  310) --> PA or segmentation violation?
+    VA  4: 0x000001e8 (decimal:  488) --> PA or segmentation violation?
+
+  For each virtual address, either write down the physical address it translates
+  to OR write down that it is an out-of-bounds address (a segmentation
+  violation). For this problem, you should assume a simple address space with
+  two segments: the top bit of the virtual address can thus be used to check
+  whether the virtual address is in segment 0 (topbit=0) or segment 1
+  (topbit=1). Note that the base/limit pairs given to you grow in different
+  directions, depending on the segment, i.e., segment 0 grows in the positive
+  direction, whereas segment 1 in the negative.
+```
+
+Then, after you have computed the translations in the virtual address trace, run
+the program again with the "-c" flag. You will see the following (not including
+the redundant information):
+
+```text
+  Virtual Address Trace
+    VA  0: 0x0000020b (decimal:  523) --> SEGMENTATION VIOLATION (SEG1)
+    VA  1: 0x0000019e (decimal:  414) --> VALID in SEG0: 0x00001c88 (decimal: 7304)
+    VA  2: 0x00000322 (decimal:  802) --> VALID in SEG1: 0x00001176 (decimal: 4470)
+    VA  3: 0x00000136 (decimal:  310) --> VALID in SEG0: 0x00001c20 (decimal: 7200)
+    VA  4: 0x000001e8 (decimal:  488) --> SEGMENTATION VIOLATION (SEG0)
+```
+
+As you can see, with -c, the program translates the addresses for you, and hence
+you can check if you understand how a system using segmentation translates
+addresses.
+
+Of course, there are some parameters you can use to give yourself different
+problems. One particularly important parameter is the -s or -seed parameter,
+which lets you generate different problems by passing in a different random
+seed. Of course, make sure to use the same random seed when you are generating a
+problem and then solving it.
+
+There are also some parameters you can use to play with different-sized address
+spaces and physical memories. For example, to experiment with segmentation in a
+tiny system, you might type:
+
+```text
+  prompt> ./segmentation.py -s 100 -a 16 -p 32
+  ARG seed 0
+  ARG address space size 16
+  ARG phys mem size 32
+
+  Segment register information:
+
+    Segment 0 base  (grows positive) : 0x00000018 (decimal 24)
+    Segment 0 limit                  : 4
+
+    Segment 1 base  (grows negative) : 0x00000012 (decimal 18)
+    Segment 1 limit                  : 5
+
+  Virtual Address Trace
+    VA  0: 0x0000000c (decimal:   12) --> PA or segmentation violation?
+    VA  1: 0x00000008 (decimal:    8) --> PA or segmentation violation?
+    VA  2: 0x00000001 (decimal:    1) --> PA or segmentation violation?
+    VA  3: 0x00000007 (decimal:    7) --> PA or segmentation violation?
+    VA  4: 0x00000000 (decimal:    0) --> PA or segmentation violation?
+```
+
+which tells the program to generate virtual addresses for a 16-byte address
+space placed somewhere in a 32-byte physical memory. As you can see, the
+resulting virtual addresses are tiny (12, 8, 1, 7, and 0). As you can also see,
+the program picks tiny base register and limit values, as appropriate. Run with
+-c to see the answers.
+
+This example should also show you exactly what each base pair means. For
+example, segment 0's base is set to a physical address of 24 (decimal) and is of
+size 4 bytes. Thus, *virtual* addresses 0, 1, 2, and 3 are in segment 0 and
+valid, and map to physical addresses 24, 25, 26, and 27, respectively.
+
+Slightly more tricky is the negative-direction-growing segment 1. In the tiny
+example above, segment 1's base register is set to physical address 18, with a
+size of 5 bytes. That means that the *last* five bytes of the virtual address
+space, in this case 11, 12, 13, 14, and 15, are valid virtual addresses, and
+that they map to physical addresses 13, 14, 15, 16, and 17, respectively.
+
+If that doesn't make sense, read it again -- you will have to make sense of how
+this works in order to do any of these problems.
+
+Note you can specify bigger values by tacking a "k", "m", or even "g" onto the
+values you pass in with the -a or -p flags, as in "kilobytes", "megabytes", and
+"gigabytes". Thus, if you wanted to do some translations with a 1-MB address
+space set in a 32-MB physical memory, you might type:
+
+```text
+prompt> ./segmentation.py -a 1m -p 32m
+```
+
+If you want to get even more specific, you can set the base register and limit
+register values yourself, with the --b0, --l0, --b1, and --l1 registers. Try
+them and see.
+
+Finally, you can always run
+
+```text
+prompt> ./segmentation.py -h
+```
+
+to get a complete list of flags and options.
+
+Enjoy!

hw3/simu2/segmentation.py

@@ -0,0 +1,193 @@
+#! /usr/bin/env python
+
+import sys
+from optparse import OptionParser
+import random
+import math
+
+def convert(size):
+    length = len(size)
+    lastchar = size[length-1]
+    if (lastchar == 'k') or (lastchar == 'K'):
+        m = 1024
+        nsize = int(size[0:length-1]) * m
+    elif (lastchar == 'm') or (lastchar == 'M'):
+        m = 1024*1024
+        nsize = int(size[0:length-1]) * m
+    elif (lastchar == 'g') or (lastchar == 'G'):
+        m = 1024*1024*1024
+        nsize = int(size[0:length-1]) * m
+    else:
+        nsize = int(size)
+    return nsize
+
+
+#
+# main program
+#
+parser = OptionParser()
+parser.add_option("-s", "--seed", default=0, help="the random seed", 
+                  action="store", type="int", dest="seed")
+parser.add_option("-A", "--addresses", default="-1",
+                  help="a set of comma-separated pages to access; -1 means randomly generate", 
+                  action="store", type="string", dest="addresses")
+parser.add_option("-a", "--asize", default="1k",
+                  help="address space size (e.g., 16, 64k, 32m, 1g)", 
+                  action="store", type="string", dest="asize")
+parser.add_option("-p", "--physmem", default="16k",
+                  help="physical memory size (e.g., 16, 64k, 32m, 1g)", 
+                  action="store", type="string", dest="psize")
+parser.add_option("-n", "--numaddrs", default=5,
+                  help="number of virtual addresses to generate",
+                  action="store", type="int", dest="num")
+parser.add_option("-b", "--b0", default="-1",
+                  help="value of segment 0 base register",
+                  action="store", type="string", dest="base0")
+parser.add_option("-l", "--l0", default="-1",
+                  help="value of segment 0 limit register",
+                  action="store", type="string", dest="len0")
+parser.add_option("-B", "--b1", default="-1",
+                  help="value of segment 1 base register",
+                  action="store", type="string", dest="base1")
+parser.add_option("-L", "--l1", default="-1",
+                  help="value of segment 1 limit register",
+                  action="store", type="string", dest="len1")
+parser.add_option("-c", help="compute answers for me",
+                  action="store_true", default=False, dest="solve")
+
+
+(options, args) = parser.parse_args()
+
+print "ARG seed", options.seed
+print "ARG address space size", options.asize
+print "ARG phys mem size", options.psize
+print ""
+
+random.seed(options.seed)
+asize = convert(options.asize)
+psize = convert(options.psize)
+addresses = str(options.addresses)
+
+if psize <= 1:
+    print 'Error: must specify a non-zero physical memory size.'
+    exit(1)
+
+if asize == 0:
+    print 'Error: must specify a non-zero address-space size.'
+    exit(1)
+
+if psize <= asize:
+    print 'Error: physical memory size must be GREATER than address space size (for this simulation)'
+    exit(1)
+
+#
+# need to generate base, bounds for segment registers
+#
+len0 = convert(options.len0)
+len1 = convert(options.len1)
+base0 = convert(options.base0)
+base1 = convert(options.base1)
+
+if len0 == -1:
+    len0 = int(asize/4.0 + (asize/4.0 * random.random()))
+
+if len1 == -1:
+    len1 = int(asize/4.0 + (asize/4.0 * random.random()))
+
+# now have to find room for them
+if base0 == -1:
+    done = 0
+    while done == 0:
+        base0 = int(psize * random.random())
+        if (base0 + len0) < psize:
+            done = 1
+
+# internally, base1 points to the lower address, and base1+len1 the higher address
+# (this differs from what the user would pass in, for example)
+if base1 == -1:
+    done = 0
+    while done == 0:
+        base1 = int(psize * random.random())
+        if (base1 + len1) < psize:
+            if (base1 > (base0 + len0)) or ((base1 + len1) < base0):
+                done = 1
+else:
+    base1 = base1 - len1
+
+
+if len0 > asize/2.0 or len1 > asize/2.0:
+    print 'Error: length register is too large for this address space'
+    exit(1)
+
+
+print 'Segment register information:'
+print ''
+print '  Segment 0 base  (grows positive) : 0x%08x (decimal %d)' % (base0, base0)
+print '  Segment 0 limit                  : %d' % (len0)
+print ''
+print '  Segment 1 base  (grows negative) : 0x%08x (decimal %d)' % (base1+len1, base1+len1)
+print '  Segment 1 limit                  : %d' % (len1)
+print ''
+nbase1  = base1 + len1
+
+if (len0 + base0) > (base1) and (base1 > base0):
+    print 'Error: segments overlap in physical memory'
+    exit(1)
+
+
+addrList = []
+if addresses == '-1':
+    # need to generate addresses
+    for i in range(0, options.num):
+        n = int(asize * random.random())
+        addrList.append(n)
+else:
+    addrList = addresses.split(',')
+
+#
+# now, need to generate virtual address trace
+#
+print 'Virtual Address Trace'
+i = 0
+for vStr in addrList:
+    # vaddr = int(asize * random.random())
+    vaddr = int(vStr)
+    if vaddr < 0 or vaddr >= asize:
+        print 'Error: virtual address %d cannot be generated in an address space of size %d' % (vaddr, asize)
+        exit(1)
+    if options.solve == False:
+        print '  VA %2d: 0x%08x (decimal: %4d) --> PA or segmentation violation?' % (i, vaddr, vaddr)
+    else:
+        paddr = 0
+        if (vaddr >= (asize / 2)):
+            # seg 1
+            paddr = nbase1 + (vaddr - asize)
+            if paddr < base1:
+                print '  VA %2d: 0x%08x (decimal: %4d) --> SEGMENTATION VIOLATION (SEG1)' % (i, vaddr, vaddr)
+            else:
+                print '  VA %2d: 0x%08x (decimal: %4d) --> VALID in SEG1: 0x%08x (decimal: %4d)' % (i, vaddr, vaddr, paddr, paddr)
+        else:
+            # seg 0
+            if (vaddr >= len0):
+                print '  VA %2d: 0x%08x (decimal: %4d) --> SEGMENTATION VIOLATION (SEG0)' % (i, vaddr, vaddr)
+            else:
+                paddr = vaddr + base0
+                print '  VA %2d: 0x%08x (decimal: %4d) --> VALID in SEG0: 0x%08x (decimal: %4d)' % (i, vaddr, vaddr, paddr, paddr)
+    i += 1
+
+print ''
+
+if options.solve == False:
+    print 'For each virtual address, either write down the physical address it translates to'
+    print 'OR write down that it is an out-of-bounds address (a segmentation violation). For'
+    print 'this problem, you should assume a simple address space with two segments: the top'
+    print 'bit of the virtual address can thus be used to check whether the virtual address'
+    print 'is in segment 0 (topbit=0) or segment 1 (topbit=1). Note that the base/limit pairs'
+    print 'given to you grow in different directions, depending on the segment, i.e., segment 0'
+    print 'grows in the positive direction, whereas segment 1 in the negative. '
+    print ''
+
+
+
+
+

hw3/simu3/QUESTIONS.md

@@ -0,0 +1,41 @@
+# Questions 17-FreeSpace-Management
+
+The program, `malloc.py`, lets you explore the behavior of a simple free-space
+allocator as described in the chapter. See the README for details of its basic
+operation.
+
+## Warm-up
+
+First run with the flags `-n 10 -H 0 -p BEST -s 0` to generate a few random
+allocations and frees. Can you predict what *alloc()*/*free()* will return? Can
+you guess the state of the free list after each request? What do you notice
+about the free list over time?
+
+## Questions
+
+1. How are the results different when using a WORST fit policy to search the
+   free list (`-p WORST`) from warm-up? What changes (Explanation)?
+
+1. What about when using FIRST fit (`-p FIRST`)? What speeds up when you use
+   first fit (Explanation)?
+
+1. For the above questions, how the list is kept ordered can affect the time it
+   takes to find a free location for some of the policies. Use the different
+   free list orderings (`-l ADDRSORT, -l SIZESORT+, -l SIZESORT-`) to see how
+   the policies and the list orderings interact. What are your observations?
+
+1. Coalescing of a free list can be quite important. Increase the number of
+   random allocations (say to `-n 1000`). What happens to larger allocation
+   requests over time? Run with and without coalescing (i.e., without and with
+   the `-C` flag). What differences in outcome do you see? How big is the free
+   list over time in each case? Does the ordering of the list matter in this
+   case? Comment your results!
+
+1. What happens when you change the percent allocated fraction `-P` to higher
+   than 50? What happens to allocations as it nears 100? What about as it nears
+   0? Please give an explanation to your observations.
+
+1. What kind of specific requests can you make to generate a highly-fragmented
+   free space? Use the `-A` flag to create fragmented free lists, and see how
+   different policies and options change the organization of the free list.
+   Explain your results.

hw3/simu3/README-malloc.md

@@ -0,0 +1,164 @@
+# README malloc
+
+This program, `malloc.py`, allows you to see how a simple memory allocator works.
+Here are the options that you have at your disposal:
+
+```text
+  -h, --help            show this help message and exit
+  -s SEED, --seed=SEED  the random seed
+  -S HEAPSIZE, --size=HEAPSIZE
+                        size of the heap
+  -b BASEADDR, --baseAddr=BASEADDR
+                        base address of heap
+  -H HEADERSIZE, --headerSize=HEADERSIZE
+                        size of the header
+  -a ALIGNMENT, --alignment=ALIGNMENT
+                        align allocated units to size; -1->no align
+  -p POLICY, --policy=POLICY
+                        list search (BEST, WORST, FIRST)
+  -l ORDER, --listOrder=ORDER
+                        list order (ADDRSORT, SIZESORT+, SIZESORT-, INSERT-FRONT, INSERT-BACK)
+  -C, --coalesce        coalesce the free list?
+  -n OPSNUM, --numOps=OPSNUM
+                        number of random ops to generate
+  -r OPSRANGE, --range=OPSRANGE
+                        max alloc size
+  -P OPSPALLOC, --percentAlloc=OPSPALLOC
+                        percent of ops that are allocs
+  -A OPSLIST, --allocList=OPSLIST
+                        instead of random, list of ops (+10,-0,etc)
+  -c, --compute         compute answers for me
+```
+
+One way to use it is to have the program generate some random allocation/free
+operations and for you to see if you can figure out what the free list would
+look like, as well as the success or failure of each operation.
+
+Here is a simple example:
+
+```text
+prompt> ./malloc.py -S 100 -b 1000 -H 4 -a 4 -l ADDRSORT -p BEST -n 5
+
+ptr[0] = Alloc(3)  returned ?
+List?
+
+Free(ptr[0]) returned ?
+List?
+
+ptr[1] = Alloc(5)  returned ?
+List?
+
+Free(ptr[1]) returned ?
+List?
+
+ptr[2] = Alloc(8)  returned ?
+List?
+```
+
+In this example, we specify a heap of size 100 bytes (-S 100), starting at
+address 1000 (-b 1000). We specify an additional 4 bytes of header per allocated
+block (-H 4), and make sure each allocated space rounds up to the nearest 4-byte
+free chunk in size (-a 4). We specify that the free list be kept ordered by
+address (increasing). Finally, we specify a "best fit" free-list searching
+policy (-p BEST), and ask for 5 random operations to be generated (-n 5). The
+results of running this are above; your job is to figure out what each
+allocation/free operation returns, as well as the state of the free list after
+each operation.
+
+Here we look at the results by using the -c option.
+
+```text
+prompt> ./malloc.py -S 100 -b 1000 -H 4 -a 4 -l ADDRSORT -p BEST -n 5 -c
+
+ptr[0] = Alloc(3)  returned 1004 (searched 1 elements)
+Free List [ Size 1 ]:  [ addr:1008 sz:92 ]
+
+Free(ptr[0]) returned 0
+Free List [ Size 2 ]:  [ addr:1000 sz:8 ] [ addr:1008 sz:92 ]
+
+ptr[1] = Alloc(5)  returned 1012 (searched 2 elements)
+Free List [ Size 2 ]:  [ addr:1000 sz:8 ] [ addr:1020 sz:80 ]
+
+Free(ptr[1]) returned 0
+Free List [ Size 3 ]:  [ addr:1000 sz:8 ] [ addr:1008 sz:12 ] [ addr:1020 sz:80 ]
+
+ptr[2] = Alloc(8)  returned 1012 (searched 3 elements)
+Free List [ Size 2 ]:  [ addr:1000 sz:8 ] [ addr:1020 sz:80 ]
+```
+
+As you can see, the first allocation operation (an allocation) returns the
+following information:
+
+```text
+ptr[0] = Alloc(3)  returned 1004 (searched 1 elements)
+Free List [ Size 1 ]:  [ addr:1008 sz:92 ]
+```
+
+Because the initial state of the free list is just one large element, it is easy
+to guess that the Alloc(3) request will succeed. Further, it will just return
+the first chunk of memory and make the remainder into a free list. The pointer
+returned will be just beyond the header (address:1004), and the allocated space
+is rounded up to 4 bytes, leaving the free list with 92 bytes starting at 1008.
+
+The next operation is a Free, of "ptr[0]" which is what stores the results of
+the previous allocation request. As you can expect, this free will succeed (thus
+returning "0"), and the free list now looks a little more complicated:
+
+```text
+Free(ptr[0]) returned 0
+Free List [ Size 2 ]:  [ addr:1000 sz:8 ] [ addr:1008 sz:92 ]
+```
+
+Indeed, because we are NOT coalescing the free list, we now have two elements on
+it, the first being 8 bytes large and holding the just-returned space, and the
+second being the 92-byte chunk.
+
+We can indeed turn on coalescing via the -C flag, and the result is:
+
+```text
+prompt> ./malloc.py -S 100 -b 1000 -H 4 -a 4 -l ADDRSORT -p BEST -n 5 -c -C
+ptr[0] = Alloc(3)  returned 1004 (searched 1 elements)
+Free List [ Size 1 ]:  [ addr:1008 sz:92 ]
+
+Free(ptr[0]) returned 0
+Free List [ Size 1 ]:  [ addr:1000 sz:100 ]
+
+ptr[1] = Alloc(5)  returned 1004 (searched 1 elements)
+Free List [ Size 1 ]:  [ addr:1012 sz:88 ]
+
+Free(ptr[1]) returned 0
+Free List [ Size 1 ]:  [ addr:1000 sz:100 ]
+
+ptr[2] = Alloc(8)  returned 1004 (searched 1 elements)
+Free List [ Size 1 ]:  [ addr:1012 sz:88 ]
+```
+
+You can see that when the Free operations take place, the free list is coalesced
+as expected.
+
+There are some other interesting options to explore:
+
+* -p (BEST, WORST, FIRST)
+
+  This option lets you use these three different strategies to look for a chunk
+  of memory to use during an allocation request
+
+* -l (ADDRSORT, SIZESORT+, SIZESORT-, INSERT-FRONT, INSERT-BACK)
+
+  This option lets you keep the free list in a particular order, say sorted by
+  address of the free chunk, size of free chunk (either increasing with a + or
+  decreasing with a -), or simply returning free chunks to the front
+  (INSERT-FRONT) or back (INSERT-BACK) of the free list.
+
+* -A (list of ops)
+
+  This option lets you specify an exact series of requests instead of
+  randomly-generated ones.
+
+  For example, running with the flag "-A +10,+10,+10,-0,-2" will allocate three
+  chunks of size 10 bytes (plus header), and then free the first one ("-0") and
+  then free the third one ("-2"). What will the free list look like then?
+
+Those are the basics. Use the questions from the book chapter to explore more,
+or create new and interesting questions yourself to better understand how
+allocators function.

hw3/simu3/malloc.py

@@ -0,0 +1,253 @@
+#! /usr/bin/env python
+
+import random
+from optparse import OptionParser
+
+class malloc:
+    def __init__(self, size, start, headerSize, policy, order, coalesce, align):
+        # size of space
+        self.size        = size
+        
+        # info about pretend headers
+        self.headerSize  = headerSize
+
+        # init free list
+        self.freelist    = []
+        self.freelist.append((start, size))
+
+        # keep track of ptr to size mappings
+        self.sizemap     = {}
+
+        # policy
+        self.policy       = policy
+        assert(self.policy in ['FIRST', 'BEST', 'WORST'])
+
+        # list ordering
+        self.returnPolicy = order
+        assert(self.returnPolicy in ['ADDRSORT', 'SIZESORT+', 'SIZESORT-', 'INSERT-FRONT', 'INSERT-BACK'])
+
+        # this does a ridiculous full-list coalesce, but that is ok
+        self.coalesce     = coalesce
+
+        # alignment (-1 if no alignment)
+        self.align        = align
+        assert(self.align == -1 or self.align > 0)
+
+    def addToMap(self, addr, size):
+        assert(addr not in self.sizemap)
+        self.sizemap[addr] = size
+        # print 'adding', addr, 'to map of size', size
+        
+    def malloc(self, size):
+        if self.align != -1:
+            left = size % self.align
+            if left != 0:
+                diff = self.align - left
+            else:
+                diff = 0
+            # print 'aligning: adding %d to %d' % (diff, size)
+            size += diff
+
+        size += self.headerSize
+
+        bestIdx  = -1
+        if self.policy == 'BEST':
+            bestSize = self.size + 1
+        elif self.policy == 'WORST' or self.policy == 'FIRST':
+            bestSize = -1
+
+        count = 0
+            
+        for i in range(len(self.freelist)):
+            eaddr, esize = self.freelist[i][0], self.freelist[i][1]
+            count   += 1
+            if esize >= size and ((self.policy == 'BEST'  and esize < bestSize) or
+                                  (self.policy == 'WORST' and esize > bestSize) or
+                                  (self.policy == 'FIRST')):
+                bestAddr = eaddr
+                bestSize = esize
+                bestIdx  = i
+                if self.policy == 'FIRST':
+                    break
+
+        if bestIdx != -1:
+            if bestSize > size:
+                # print 'SPLIT', bestAddr, size
+                self.freelist[bestIdx] = (bestAddr + size, bestSize - size)
+                self.addToMap(bestAddr, size)
+            elif bestSize == size:
+                # print 'PERFECT MATCH (no split)', bestAddr, size
+                self.freelist.pop(bestIdx)
+                self.addToMap(bestAddr, size)
+            else:
+                abort('should never get here')
+            return (bestAddr, count)
+
+        # print '*** FAILED TO FIND A SPOT', size
+        return (-1, count)
+
+    def free(self, addr):
+        # simple back on end of list, no coalesce
+        if addr not in self.sizemap:
+            return -1
+            
+        size = self.sizemap[addr]
+        if self.returnPolicy == 'INSERT-BACK':
+            self.freelist.append((addr, size))
+        elif self.returnPolicy == 'INSERT-FRONT':
+            self.freelist.insert(0, (addr, size))
+        elif self.returnPolicy == 'ADDRSORT':
+            self.freelist.append((addr, size))
+            self.freelist = sorted(self.freelist, key=lambda e: e[0])
+        elif self.returnPolicy == 'SIZESORT+':
+            self.freelist.append((addr, size))
+            self.freelist = sorted(self.freelist, key=lambda e: e[1], reverse=False)
+        elif self.returnPolicy == 'SIZESORT-':
+            self.freelist.append((addr, size))
+            self.freelist = sorted(self.freelist, key=lambda e: e[1], reverse=True)
+
+        # not meant to be an efficient or realistic coalescing...
+        if self.coalesce == True:
+            self.newlist = []
+            self.curr    = self.freelist[0]
+            for i in range(1, len(self.freelist)):
+                eaddr, esize = self.freelist[i]
+                if eaddr == (self.curr[0] + self.curr[1]):
+                    self.curr = (self.curr[0], self.curr[1] + esize)
+                else:
+                    self.newlist.append(self.curr)
+                    self.curr = eaddr, esize
+            self.newlist.append(self.curr)
+            self.freelist = self.newlist
+            
+        del self.sizemap[addr]
+        return 0
+
+    def dump(self):
+        print 'Free List [ Size %d ]: ' % len(self.freelist), 
+        for e in self.freelist:
+            print '[ addr:%d sz:%d ]' % (e[0], e[1]),
+        print ''
+
+
+#
+# main program
+#
+parser = OptionParser()
+
+parser.add_option('-s', '--seed',        default=0,          help='the random seed',                             action='store', type='int',    dest='seed')
+parser.add_option('-S', '--size',        default=100,        help='size of the heap',                            action='store', type='int',    dest='heapSize') 
+parser.add_option('-b', '--baseAddr',    default=1000,       help='base address of heap',                        action='store', type='int',    dest='baseAddr') 
+parser.add_option('-H', '--headerSize',  default=0,          help='size of the header',                          action='store', type='int',    dest='headerSize')
+parser.add_option('-a', '--alignment',   default=-1,         help='align allocated units to size; -1->no align', action='store', type='int',    dest='alignment')
+parser.add_option('-p', '--policy',      default='BEST',     help='list search (BEST, WORST, FIRST)',            action='store', type='string', dest='policy') 
+parser.add_option('-l', '--listOrder',   default='ADDRSORT', help='list order (ADDRSORT, SIZESORT+, SIZESORT-, INSERT-FRONT, INSERT-BACK)', action='store', type='string', dest='order') 
+parser.add_option('-C', '--coalesce',    default=False,      help='coalesce the free list?',                     action='store_true',           dest='coalesce')
+parser.add_option('-n', '--numOps',      default=10,         help='number of random ops to generate',            action='store', type='int',    dest='opsNum')
+parser.add_option('-r', '--range',       default=10,         help='max alloc size',                              action='store', type='int',    dest='opsRange')
+parser.add_option('-P', '--percentAlloc',default=50,         help='percent of ops that are allocs',              action='store', type='int',    dest='opsPAlloc')
+parser.add_option('-A', '--allocList',   default='',         help='instead of random, list of ops (+10,-0,etc)', action='store', type='string', dest='opsList')
+parser.add_option('-c', '--compute',     default=False,      help='compute answers for me',                      action='store_true',           dest='solve')
+
+(options, args) = parser.parse_args()
+
+m = malloc(int(options.heapSize), int(options.baseAddr), int(options.headerSize),
+           options.policy, options.order, options.coalesce, options.alignment)
+
+print 'seed', options.seed
+print 'size', options.heapSize
+print 'baseAddr', options.baseAddr
+print 'headerSize', options.headerSize
+print 'alignment', options.alignment
+print 'policy', options.policy
+print 'listOrder', options.order
+print 'coalesce', options.coalesce
+print 'numOps', options.opsNum
+print 'range', options.opsRange
+print 'percentAlloc', options.opsPAlloc
+print 'allocList', options.opsList
+print 'compute', options.solve
+print ''
+
+percent = int(options.opsPAlloc) / 100.0
+
+random.seed(int(options.seed))
+p = {}
+L = []
+assert(percent > 0)
+
+if options.opsList == '':
+    c = 0
+    j = 0
+    while j < int(options.opsNum):
+        pr = False
+        if random.random() < percent:
+            size     = int(random.random() * int(options.opsRange)) + 1
+            ptr, cnt = m.malloc(size)
+            if ptr != -1:
+                p[c] = ptr
+                L.append(c)
+            print 'ptr[%d] = Alloc(%d)' % (c, size),
+            if options.solve == True:
+                print ' returned %d (searched %d elements)' % (ptr + options.headerSize, cnt)
+            else:
+                print ' returned ?'
+            c += 1
+            j += 1
+            pr = True
+        else:
+            if len(p) > 0:
+                # pick random one to delete
+                d = int(random.random() * len(L))
+                rc = m.free(p[L[d]])
+                print 'Free(ptr[%d])' % L[d], 
+                if options.solve == True:
+                    print 'returned %d' % rc
+                else:
+                    print 'returned ?'
+                del p[L[d]]
+                del L[d]
+                # print 'DEBUG p', p
+                # print 'DEBUG L', L
+                pr = True
+                j += 1
+        if pr:
+            if options.solve == True:
+                m.dump()
+            else:
+                print 'List? '
+            print ''
+else:
+    c = 0
+    for op in options.opsList.split(','):
+        if op[0] == '+':
+            # allocation!
+            size     = int(op.split('+')[1])
+            ptr, cnt = m.malloc(size)
+            if ptr != -1:
+                p[c] = ptr
+            print 'ptr[%d] = Alloc(%d)' % (c, size),
+            if options.solve == True:
+                print ' returned %d (searched %d elements)' % (ptr, cnt)
+            else:
+                print ' returned ?'
+            c += 1
+        elif op[0] == '-':
+            # free
+            index = int(op.split('-')[1])
+            if index >= len(p):
+                print 'Invalid Free: Skipping'
+                continue
+            print 'Free(ptr[%d])' % index, 
+            rc = m.free(p[index])
+            if options.solve == True:
+                print 'returned %d' % rc
+            else:
+                print 'returned ?'
+        else:
+            abort('badly specified operand: must be +Size or -Index')
+        if options.solve == True:
+            m.dump()
+        else:
+            print 'List?'
+        print ''

hw3/simu4/QUESTIONS.md

@@ -0,0 +1,69 @@
+# Questions 18-Paging-Linear-Translate
+
+In this simulation task, 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. See the
+README for details.
+
+## Questions
+
+1. Before doing any translations, let’s use the simulator to study how linear
+   page tables change size given different parameters. Compute the size of
+   linear page tables as different parameters change. Some suggested inputs are
+   below; by using the `-v` flag, you can see how many page-table entries are
+   filled.
+
+   First, to understand how linear page table size changes as the address space
+   grows:
+
+   ```text
+      paging-linear-translate.py -P 1k -a 1m -p 512m -v -n 0
+      paging-linear-translate.py -P 1k -a 2m -p 512m -v -n 0
+      paging-linear-translate.py -P 1k -a 4m -p 512m -v -n 0
+   ```
+
+   Then, to understand how linear page table size changes as page size grows:
+
+   ```text
+      paging-linear-translate.py -P 1k -a 1m -p 512m -v -n 0
+      paging-linear-translate.py -P 2k -a 1m -p 512m -v -n 0
+      paging-linear-translate.py -P 4k -a 1m -p 512m -v -n 0
+   ```
+
+   Before running any of these, try to think about the expected trends.
+
+    1.1. How can the page table size governed in equations? Give the equations to show, which parameters govern the page table size.
+
+    1.2. How should page-table size change as the address space grows? As the page size grows?
+
+    1.3. Why shouldn’t we just use really big pages in general?
+
+1. Now let’s do some translations. Start with some small examples, and change
+   the number of pages that are allocated to the address space with the `-u`
+   flag. For example:
+
+   ```text
+      paging-linear-translate.py -P 1k -a 16k -p 32k -v -u 0
+      paging-linear-translate.py -P 1k -a 16k -p 32k -v -u 25
+      paging-linear-translate.py -P 1k -a 16k -p 32k -v -u 50
+      paging-linear-translate.py -P 1k -a 16k -p 32k -v -u 75
+      paging-linear-translate.py -P 1k -a 16k -p 32k -v -u 100
+   ```
+
+   What happens as you increase the percentage of pages that are allocated in
+   each address space?
+
+1. Now let’s try some different random seeds, and some different (and sometimes
+   quite crazy) address-space parameters, for variety:
+
+   ```text
+      paging-linear-translate.py -P 8  -a 32   -p 1024 -v -s 1
+      paging-linear-translate.py -P 8k -a 32k  -p 1m   -v -s 2
+      paging-linear-translate.py -P 1m -a 256m -p 512m -v -s 3
+   ```
+
+   Which of these parameter combinations are unrealistic? Why?
+
+1. Use the program to try out some other problems. Can you find the limits of
+   where the program doesn’t work anymore? For example, what happens if the
+   address-space size is bigger than physical memory?

hw3/simu4/README-paging-linear-translate.md

@@ -0,0 +1,135 @@
+# README Paging: Linear-Translation
+
+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:
+
+```text
+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:
+
+```text
+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:
+
+```text
+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):
+
+```text
+...
+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.

hw3/simu4/paging-linear-translate.py

@@ -0,0 +1,192 @@
+#! /usr/bin/env python
+
+import sys
+from optparse import OptionParser
+import random
+import math
+
+def mustbepowerof2(bits, size, msg):
+    if math.pow(2,bits) != size:
+        print 'Error in argument: %s' % msg
+        sys.exit(1)
+
+def mustbemultipleof(bignum, num, msg):
+    if (int(float(bignum)/float(num)) != (int(bignum) / int(num))):
+        print 'Error in argument: %s' % msg
+        sys.exit(1)
+
+def convert(size):
+    length = len(size)
+    lastchar = size[length-1]
+    if (lastchar == 'k') or (lastchar == 'K'):
+        m = 1024
+        nsize = int(size[0:length-1]) * m
+    elif (lastchar == 'm') or (lastchar == 'M'):
+        m = 1024*1024
+        nsize = int(size[0:length-1]) * m
+    elif (lastchar == 'g') or (lastchar == 'G'):
+        m = 1024*1024*1024
+        nsize = int(size[0:length-1]) * m
+    else:
+        nsize = int(size)
+    return nsize
+
+
+#
+# main program
+#
+parser = OptionParser()
+parser.add_option('-A', '--addresses', default='-1',
+                  help='a set of comma-separated pages to access; -1 means randomly generate', 
+                  action='store', type='string', dest='addresses')
+parser.add_option('-s', '--seed',    default=0,     help='the random seed',                               action='store', type='int', dest='seed')
+parser.add_option('-a', '--asize',   default='16k', help='address space size (e.g., 16, 64k, 32m, 1g)',   action='store', type='string', dest='asize')
+parser.add_option('-p', '--physmem', default='64k', help='physical memory size (e.g., 16, 64k, 32m, 1g)', action='store', type='string', dest='psize')
+parser.add_option('-P', '--pagesize', default='4k', help='page size (e.g., 4k, 8k, whatever)',            action='store', type='string', dest='pagesize')
+parser.add_option('-n', '--numaddrs',  default=5,  help='number of virtual addresses to generate',       action='store', type='int', dest='num')
+parser.add_option('-u', '--used',       default=50, help='percent of virtual address space that is used', action='store', type='int', dest='used')
+parser.add_option('-v',                             help='verbose mode',                                  action='store_true', default=False, dest='verbose')
+parser.add_option('-c',                             help='compute answers for me',                        action='store_true', default=False, dest='solve')
+
+
+(options, args) = parser.parse_args()
+
+print 'ARG seed',               options.seed
+print 'ARG address space size', options.asize
+print 'ARG phys mem size',      options.psize
+print 'ARG page size',          options.pagesize
+print 'ARG verbose',            options.verbose
+print 'ARG addresses',          options.addresses
+print ''
+
+random.seed(options.seed)
+
+asize    = convert(options.asize)
+psize    = convert(options.psize)
+pagesize = convert(options.pagesize)
+addresses = str(options.addresses)
+
+if psize <= 1:
+    print 'Error: must specify a non-zero physical memory size.'
+    exit(1)
+
+if asize < 1:
+    print 'Error: must specify a non-zero address-space size.'
+    exit(1)
+
+if psize <= asize:
+    print 'Error: physical memory size must be GREATER than address space size (for this simulation)'
+    exit(1)
+
+if psize >= convert('1g') or asize >= convert('1g'):
+    print 'Error: must use smaller sizes (less than 1 GB) for this simulation.'
+    exit(1)
+
+mustbemultipleof(asize, pagesize, 'address space must be a multiple of the pagesize')
+mustbemultipleof(psize, pagesize, 'physical memory must be a multiple of the pagesize')
+
+# print some useful info, like the darn page table 
+pages = psize / pagesize;
+import array
+used = array.array('i')
+pt   = array.array('i')
+for i in range(0,pages):
+    used.insert(i,0)
+vpages = asize / pagesize
+
+# now, assign some pages of the VA
+vabits   = int(math.log(float(asize))/math.log(2.0))
+mustbepowerof2(vabits, asize, 'address space must be a power of 2')
+pagebits = int(math.log(float(pagesize))/math.log(2.0))
+mustbepowerof2(pagebits, pagesize, 'page size must be a power of 2')
+vpnbits  = vabits - pagebits
+pagemask = (1 << pagebits) - 1
+
+# import ctypes
+# vpnmask  = ctypes.c_uint32(~pagemask).value
+vpnmask = 0xFFFFFFFF & ~pagemask
+#if vpnmask2 != vpnmask:
+#    print 'ERROR'
+#    exit(1)
+# print 'va:%d page:%d vpn:%d -- %08x %08x' % (vabits, pagebits, vpnbits, vpnmask, pagemask)
+
+print ''
+print 'The format of the page table is simple:'
+print 'The high-order (left-most) bit is the VALID bit.'
+print '  If the bit is 1, the rest of the entry is the PFN.'
+print '  If the bit is 0, the page is not valid.'
+print 'Use verbose mode (-v) if you want to print the VPN # by'
+print 'each entry of the page table.'
+print ''
+
+print 'Page Table (from entry 0 down to the max size)'
+for v in range(0,vpages):
+    done = 0
+    while done == 0:
+        if ((random.random() * 100.0) > (100.0 - float(options.used))):
+            u = int(pages * random.random())
+            if used[u] == 0:
+                done = 1
+                # print '%8d - %d' % (v, u)
+                if options.verbose == True:
+                    print '  [%8d]  ' % v,
+                else:
+                    print '  ',
+                print '0x%08x' % (0x80000000 | u)
+                pt.insert(v,u)
+        else:
+            # print '%8d - not valid' % v
+            if options.verbose == True:
+                print '  [%8d]  ' % v,
+            else:
+                print '  ',
+            print '0x%08x' % 0
+            pt.insert(v,-1)
+            done = 1
+print ''            
+
+
+#
+# now, need to generate virtual address trace
+#
+
+addrList = []
+if addresses == '-1':
+    # need to generate addresses
+    for i in range(0, options.num):
+        n = int(asize * random.random())
+        addrList.append(n)
+else:
+    addrList = addresses.split(',')
+
+
+print 'Virtual Address Trace'
+for vStr in addrList:
+    # vaddr = int(asize * random.random())
+    vaddr = int(vStr)
+    if options.solve == False:
+        print '  VA 0x%08x (decimal: %8d) --> PA or invalid address?' % (vaddr, vaddr)
+    else:
+        paddr = 0
+        # split vaddr into VPN | offset
+        vpn = (vaddr & vpnmask) >> pagebits
+        if pt[vpn] < 0:
+            print '  VA 0x%08x (decimal: %8d) -->  Invalid (VPN %d not valid)' % (vaddr, vaddr, vpn)
+        else:
+            pfn    = pt[vpn]
+            offset = vaddr & pagemask
+            paddr  = (pfn << pagebits) | offset
+            print '  VA 0x%08x (decimal: %8d) --> %08x (decimal %8d) [VPN %d]' % (vaddr, vaddr, paddr, paddr, vpn)
+print ''
+
+if options.solve == False:
+    print 'For each virtual address, write down the physical address it translates to'
+    print 'OR write down that it is an out-of-bounds address (e.g., segfault).'
+    print ''
+
+
+
+
+
+
+