Merge branch 'hw6' of https://github.com/themultiplexer/bsys-ws17-grp11 into hw6

.gitignore

@@ -1,15 +0,0 @@
-# Generated by Cargo
-# will have compiled files and executables
-*/*/target/
-
-# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
-# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
-Cargo.lock
-
-# These are backup files generated by rustfmt
-**/*.rs.bk
-
-*.swp
-
-# Files generated by IntelliJ IDEA
-*.idea

GRADING.md

@@ -1 +1,49 @@
 # Grading
+
+### hw1 (kein PR gestellt)
+
+| Task | Credits | Comment |
+|---|---|---|
+| simu1 | 0 | |
+| task1 | 0 | |
+| task2 | 0 | |
+| task3 | 0 | |
+| task4 | 0 | |
+| simu2 | 0 | |
+| task5 | 0 | |
+| Deadline | 0 | |
+| = | 0 | |
+
+### hw2
+
+| Task | Credits | Comment |
+|---|---|---|
+| task1 | 1 | |
+| task2 | 2 | |
+| task3 | 1 | |
+| simu1 | 0,7 | Frage 5 und 7 nicht beantwortet|
+| Deadline | 1 | |
+| = | 5,7 | |
+
+### hw3
+
+| Task | Credits | Comment |
+| --- | --- | --- |
+| simu1    | 1 |  |
+| simu2    | 0,8 | Anteiliger Abzug (1) |
+| simu3    | 0,7 | Anteiliger Abzug für (4,6) |
+| simu4    | 0,9 | Anteiliger Abzug für (1.3) |
+| Deadline | 0,9 | Anteiliger Abzug |
+| = | 4,3 | |
+
+### hw4
+
+| Task     | Credits | Comment |
+| -------- | ------- | ------- |
+| task1    | 2        |         |
+| simu1    | 0,08        | Anteilige Abzüge(1,2,3)        |
+| simu2    | 1       |         |
+| simu3    | 0,33        | Anteilige Abzüge(2,3)       |
+| task2    | 0       | nicht bearbeitet         |
+| Deadline | 0,9       |         |
+| =        | 4,31       |         |

README.md

@@ -20,7 +20,9 @@
 
 In diesem Ordner werden die Aufgaben (Homework,`hw`) veröffentlicht, die bearbeitet werden müssen, um den Schein in BSYS zu bekommen.
 
-Eine Homework besteht aus einer oder mehreren Tasks. Sie finden somit die zu einer Homework gehörenden Aufgaben in den `README.md`, Dateien der zughörigen `hwN/taskN/` Ordner. `N` steht als Platzhalter für die entsprechende Homework bzw. Tasknummer.
+Eine Homework besteht aus einer oder mehreren Tasks. Sie finden somit die zu einer Homework gehörenden Aufgaben in den `README.md`, Dateien der zughörigen `hwN/taskN/` Ordner.
+
+> `N` steht als Platzhalter für die entsprechende Homework bzw. Tasknummer.
 
 ## Vorbereitung
 Die folgenden Befehle demonstrieren den prinzipiellen technischen Ablauf um die Aufgaben vorzubereiten.
@@ -33,13 +35,13 @@ Nach der Vorbereitung haben beide Gruppenmitglieder eine lokale Kopie des Git-Re
 > Wer UserA und UserB ist, ist nicht wichtig, darf aber während des gesamten Ablaufs nicht verändert werden!
 
 ### User A and User B @ Github:
-* Visit invitation link and join _grp$N_
+* Visit invitation link and join _grpN_
 
 ## Git and GitHub Preparations
 
 ### User A @ GitHub
-* *htwg-syslab-bsys-ws17/bsys-ws17-grp$N* -> fork -> *UserA/bsys-ws17-grp$N*
-* Add _UserB_ as collaborator to *UserA/bsys-ws17-grp$N*
+* *htwg-syslab-bsys-ws17/bsys-ws17-grpN* -> fork -> *UserA/bsys-ws17-grpN*
+* Add _UserB_ as collaborator to *UserA/bsys-ws17-grpN*
 
 ### User A @ Container:
 

files/hw1.txt

@@ -0,0 +1,34 @@
+./hw1/README.md
+./hw1/simu1/README-process-run.md
+./hw1/simu1/ANSWERS.md
+./hw1/simu1/QUESTIONS.md
+./hw1/simu1/process-run.py
+
+
+./hw1/simu2/QUESTIONS.md
+?./hw1/simu2/ANSWERS.md
+
+./hw1/task1/Cargo.toml
+./hw1/task1/src/lib.rs
+./hw1/task1/tests/task1.rs
+
+
+./hw1/task2/Cargo.toml
+./hw1/task2/src/lib.rs
+./hw1/task2/tests/task2.rs
+
+
+./hw1/task3/Cargo.toml
+./hw1/task3/src/lib.rs
+./hw1/task3/tests/task3.rs
+
+
+./hw1/task4/Cargo.toml
+./hw1/task4/src/lib.rs
+./hw1/task4/tests/task4.rs
+
+./hw1/task5/Cargo.toml
+./hw1/task5/Cargo.lock
+./hw1/task5/src/main.rs
+./hw1/task5/tests/output.bats
+

files/hw2.txt

@@ -0,0 +1,21 @@
+./hw2/README.md
+./hw2/simu1/ANSWERS.md
+./hw2/simu1/QUESTIONS.md
+./hw2/simu1/null.c
+
+./hw2/task1/README.md
+./hw2/task1/Cargo.toml
+./hw2/task1/tests/task1.rs
+./hw2/task1/src/lib.rs
+
+./hw2/task2/README.md
+./hw2/task2/Cargo.toml
+./hw2/task2/Cargo.lock
+./hw2/task2/tests/task2.rs
+./hw2/task2/src/lib.rs
+./hw2/task2/src/main.rs
+
+?./hw2/task3/README.md
+?./hw2/task3/Cargo.toml
+?./hw2/task3/tests/task3.rs
+?./hw2/task3/src/lib.rs

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
+

files/hw4.txt

@@ -0,0 +1,27 @@
+./hw4/README.md
+
+./hw4/simu1/ANSWERS.md
+./hw4/simu1/QUESTIONS.md
+./hw4/simu1/paging-multilevel-translate.py
+./hw4/simu1/README-paging-multilevel-translate.md
+
+./hw4/simu2/ANSWERS.md
+./hw4/simu2/QUESTIONS.md
+./hw4/simu2/Makefile
+./hw4/simu2/mem.c
+./hw4/simu2/README-mem-vmstat.md
+
+./hw4/simu3/ANSWERS.md
+./hw4/simu3/QUESTIONS.md
+./hw4/simu3/README-paging-policy.md
+./hw4/simu3/paging-policy.py
+
+./hw4/task1/Cargo.lock
+./hw4/task1/Cargo.toml
+./hw4/task1/src/main.rs
+./hw4/task1/src/pstree.rs
+./hw4/task1/src/readproc.rs
+./hw4/task1/src/unit_test_readproc.rs
+./hw4/task1/src/unit_test_pstree.rs
+./hw4/task1/tests/output.bats
+

files/hw5.txt

@@ -0,0 +1,20 @@
+./hw5/README.md
+
+./hw5/task1/Cargo.lock
+./hw5/task1/Cargo.toml
+./hw5/task1/src/main.rs
+./hw5/task1/src/zombie/mod.rs
+./hw5/task1/src/child/mod.rs
+./hw5/task1/src/child/pstree.rs
+./hw5/task1/src/unit_tests.rs
+./hw5/task1/tests/output.bats
+
+./hw5/simu1/ANSWERS.md
+./hw5/simu1/QUESTIONS.md
+./hw5/simu1/README-scheduler.md
+./hw5/simu1/scheduler.py
+
+./hw5/simu2/ANSWERS.md
+./hw5/simu2/QUESTIONS.md
+./hw5/simu2/README-mlfq.md
+./hw5/simu2/mlfq.py

hw0/README.md

@@ -0,0 +1,37 @@
+# HW0 - Git Übung
+In dieser Übung wird der Umgang mit `git` auf der Kommandozeile gelernt.
+
+## Vorbereitung
+Updates des Templates herunterladen und neue Feature-Branches für jeden Benutzer erstellen.
+
+### User A @ Container:
+```bash
+cd ~/src/htwg-syslab-bsys-ws17/bsys-ws17-grpN
+git fetch --all
+git checkout hw0
+git push origin hw0
+git checkout -b hw0-UserA
+git push origin hw0-UserA
+```
+
+### User B @ Container:
+```bash
+cd ~/src/htwg-syslab-bsys-ws17/bsys-ws17-grpN
+```
+
+Hole die neusten Informationen aller Remotes
+```bash
+git fetch --all
+```
+
+Verwende *origin/hw0* als Basis für die neue lokale *hw0* Branch
+```bash
+git checkout origin/hw0
+git checkout -b hw0
+```
+
+Zweige von *hw0* ab nach *hw0-UserB* und push nach auf den Fork von UserA (origin)
+```bash
+git checkout -b hw0-UserB
+git push origin hw0-UserB
+```

hw0/gittask0/README.md

@@ -0,0 +1,81 @@
+# HW0 - gittask0
+
+## Vorbereitung
+
+### User A @ Container
+```bash
+cd ~/src/htwg-syslab-bsys-ws17/bsys-ws17-grpN
+git status # verify that the branch is hw0-UserA
+```
+
+### User B @ Container
+```bash
+cd ~/src/htwg-syslab-bsys-ws17/bsys-ws17-grpN
+git status # verify that the branch is hw0-UserB
+```
+
+## Konflikterzeugung
+Beide Benutzer verändern auf ihrer lokalen Kopie eine Datei und laden diese Änderung hoch.
+Beim zusammenführen fällt der Konflikt dann auf, und muss von einem Benutzer behoben werden.
+
+### User A @ Container
+* Ersetze die beiden Fragezeichen in der Tabelle mit jeweils Namen und Github Benutzernamen.
+* Ersetze das N in der Überschrift durch die Gruppennummer
+
+```bash
+git commit -v SOLUTION.md
+git push
+```
+
+### User A @ GitHub
+* Erstelle einen Pull-Request von _hw0-UserA_ auf _hw0_.
+
+    ![PR1](../.gfx/github-pr1.png)
+
+### User B @ Container
+* Ersetze die beiden Fragezeichen in der Tabelle mit jeweils Namen und Github Benutzernamen.
+* Ersetze das N in der Überschrift durch die Gruppennummer
+
+```bash
+git commit -v SOLUTION.md
+git push
+```
+
+### User B @ GitHub
+* Bestätige den Pull-Request von User A
+* Erstelle einen Pull-Request von _hw0-UserB_ auf _hw0_.
+
+    ![PR2](../.gfx/github-pr2.png)
+* **Konflikt tritt auf!**
+
+## Konfliktbehandlung
+
+### User B @ Container
+* Bestätige den Pull-Request von User A
+* Erstelle einen Pull-Request von _hw0-UserB_ auf _hw0_.
+  **Konflikt tritt auf!**
+
+### User B @ Container
+```bash
+git checkout hw0
+git pull
+git checkout hw0-UserB
+git merge hw0
+# edit SOLUTIONS.md
+git commit -v SOLUTIONS.md
+git push
+```
+
+### User A @ GitHub
+* Bestätige den Pull-Request von User B
+
+### User A @ Container
+```bash
+git checkout hw0
+git pull
+```
+
+## Abgabe
+
+### User A @ GitHub
+* Öffne Upstream Repository und erstelle Pull-Request von der _hw0_ von UserA's fork auf _master_ Branch des Upstream Repository

hw0/gittask0/SOLUTION.md

@@ -0,0 +1,6 @@
+# Gruppe 11
+
+Name | Github Benutzer
+--- | ---
+Lorenz Bung | LorenzBung
+Joshua Rutschmann | themultiplexer

hw1/README.md

@@ -0,0 +1,47 @@
+# hw1
+
+## Tasks
+To fullfill **hw1** you have to solve:
+
+- task1
+- task2
+- task3
+- task4
+- simu1
+
+Optinal are (bonus +1P):
+
+- task5
+- simu2
+
+## Files
+You find already files for earch rust task.
+
+## 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.
+
+## Pull-Reuest
+
+If you are ready with the homework, all tests run, please create a pull request named **hw1**.
+
+## Gradings
+
+### hw1
+
+| Task | max. Credits | Comment |
+|---|---|---|
+| simu1 | 1 | |
+| task1 | 1 | |
+| task2 | 1 | |
+| task3 | 0,5 | |
+| task4 | 0,5 | |
+| simu2 | +0,5 | |
+| task5 | +0,5 | |
+| Deadline | +1 | |
+| = | 6 | |

hw1/simu1/QUESTIONS.md

@@ -0,0 +1,35 @@
+# Questions 4-Process-Run Simulation Part 1
+
+This program, `process-run.py`, allows you to see how process states change as programs run and either use the CPU (e.g., perform an add instruction) or do I/O (e.g., send a request to a disk and wait for it to complete). See the README for details.
+
+Please answer the questions, by giving the result and an explanation, why you got the result. Sometimes it could be helpful, if you compare your result with results of earlier questions. Write your answers in [markdown syntax][]  in the new file `ANSWERS.md.`
+
+1. Run the program with the following flags:
+
+ ```text
+./process-run.py -l 5:100,5:100.
+ ```
+
+ What should the CPU utilization be (e.g., the percent of time the CPU is in use?) Why do you know this? Use the `-c` and `-p` flags to see if you were right.
+
+2. Now run with these flags:
+
+ ```text
+./process-run.py -l 4:100,1:0.
+ ```
+
+ These flags specify one process with 4 instructions (all to use the CPU), and one that simply issues an I/O and waits for it to be done. How long does it take to complete both processes? Use `-c` and `-p` to find out if you were right.
+
+3. Now switch the order of the processes:
+
+ ```text
+./process-run.py -l 1:0,4:100.
+ ```
+
+ What happens now? Does switching the order matter? Why? (As always, use `-c` and `-p` to see if you were right)
+
+4. We’ll now explore some of the other flags. One important flag is `-S`, which determines how the system reacts when a process issues an I/O. With the flag set to `SWITCH_ON_END`, the system will NOT switch to another process while one is doing I/O, instead waiting until the process is completely finished. What happens when you run the following two processes, one doing I/O and the other doing CPU work? (`-l 1:0,4:100 -c -S SWITCH_ON_END`)
+
+5. Now, run the same processes, but with the switching behavior set to switch to another process whenever one is WAITING for I/O (`-l 1:0,4:100 -c -S SWITCH ON IO`). What happens now? Use `-c` and `-p` to confirm that you are right.
+
+[markdown syntax]: https://guides.github.com/features/mastering-markdown/

hw1/simu1/README-process-run.md

@@ -0,0 +1,236 @@
+# README Process Run
+
+
+This program, called `process-run.py`, allows you to see how the state of a
+process state changes as it runs on a CPU. As described in the chapter,
+processes can be in a few different states:
+
+```text
+  RUNNING - the process is using the CPU right now
+  READY   - the process could be using the CPU right now
+            but (alas) some other process is
+  WAITING - the process is waiting on I/O
+            (e.g., it issued a request to a disk)
+  DONE    - the process is finished executing
+```
+
+In this homework, we'll see how these process states change as a program
+runs, and thus learn a little bit better how these things work.
+
+To run the program and get its options, do this:
+
+```text
+prompt> ./process-run.py -h
+````
+
+If this doesn't work, type "python" before the command, like this:
+
+```text
+prompt> python process-run.py -h
+```
+
+What you should see is this:
+
+```text
+Usage: process-run.py [options]
+
+Options:
+  -h, --help            show this help message and exit
+  -s SEED, --seed=SEED  the random seed
+  -l PROCESS_LIST, --processlist=PROCESS_LIST
+                        a comma-separated list of processes to run, in the
+                        form X1:Y1,X2:Y2,... where X is the number of
+                        instructions that process should run, and Y the
+                        chances (from 0 to 100) that an instruction will use
+                        the CPU or issue an IO
+  -L IO_LENGTH, --iolength=IO_LENGTH
+                        how long an IO takes
+  -S PROCESS_SWITCH_BEHAVIOR, --switch=PROCESS_SWITCH_BEHAVIOR
+                        when to switch between processes: SWITCH_ON_IO,
+                        SWITCH_ON_END
+  -I IO_DONE_BEHAVIOR, --iodone=IO_DONE_BEHAVIOR
+                        type of behavior when IO ends: IO_RUN_LATER,
+                        IO_RUN_IMMEDIATE
+  -c                    compute answers for me
+  -p, --printstats      print statistics at end; only useful with -c flag
+                        (otherwise stats are not printed)
+```
+
+The most important option to understand is the **PROCESS_LIST** (as specified by
+the -l or --processlist flags) which specifies exactly what each running
+program (or "process") will do. A process consists of instructions, and each
+instruction can just do one of two things:
+
+- use the CPU
+- issue an IO (and wait for it to complete)
+
+When a process uses the CPU (and does no IO at all), it should simply
+alternate between RUNNING on the CPU or being READY to run. For example, here
+is a simple run that just has one program being run, and that program only
+uses the CPU (it does no IO).
+
+```text
+prompt> ./process-run.py -l 5:100
+Produce a trace of what would happen when you run these processes:
+Process 0
+  cpu
+  cpu
+  cpu
+  cpu
+  cpu
+
+Important behaviors:
+  System will switch when the current process is FINISHED or ISSUES AN IO
+  After IOs, the process issuing the IO will run LATER (when it is its turn)
+
+prompt>
+```
+
+Here, the process we specified is "5:100" which means it should consist of 5
+instructions, and the chances that each instruction is a CPU instruction are
+100%.
+
+You can see what happens to the process by using the -c flag, which computes the
+answers for you:
+
+```text
+prompt> ./process-run.py -l 5:100 -c
+Time     PID: 0        CPU        IOs
+  1     RUN:cpu          1
+  2     RUN:cpu          1
+  3     RUN:cpu          1
+  4     RUN:cpu          1
+  5     RUN:cpu          1
+````
+
+This result is not too interesting: the process is simple in the **RUN** state and then finishes, using the CPU the whole time and thus keeping the CPU busy the entire run, and not doing any I/Os.
+
+Let's make it slightly more complex by running two processes:
+
+```text
+prompt> ./process-run.py -l 5:100,5:100
+Produce a trace of what would happen when you run these processes:
+Process 0
+  cpu
+  cpu
+  cpu
+  cpu
+  cpu
+
+Process 1
+  cpu
+  cpu
+  cpu
+  cpu
+  cpu
+
+
+Important behaviors:
+  Scheduler will switch when the current process is FINISHED or ISSUES AN IO
+  After IOs, the process issuing the IO will run LATER (when it is its turn)
+```
+
+In this case, two different processes run, each again just using the CPU. What
+happens when the operating system runs them? Let's find out:
+
+```text
+prompt> ./process-run.py -l 5:100,5:100 -c
+Time     PID: 0     PID: 1        CPU        IOs
+  1     RUN:cpu      READY          1
+  2     RUN:cpu      READY          1
+  3     RUN:cpu      READY          1
+  4     RUN:cpu      READY          1
+  5     RUN:cpu      READY          1
+  6        DONE    RUN:cpu          1
+  7        DONE    RUN:cpu          1
+  8        DONE    RUN:cpu          1
+  9        DONE    RUN:cpu          1
+ 10        DONE    RUN:cpu          1
+```
+
+As you can see above, first the process with "process ID" (or "PID") 0 runs,
+while process 1 is READY to run but just waits until 0 is done. When 0 is
+finished, it moves to the DONE state, while 1 runs. When 1 finishes, the trace
+is done.
+
+Let's look at one more example before getting to some questions. In this
+example, the process just issues I/O requests. We specify here tht I/Os take 5
+time units to complete with the flag -L.
+
+```text
+prompt> ./process-run.py -l 3:0 -L 5
+Produce a trace of what would happen when you run these processes:
+Process 0
+  io-start
+  io-start
+  io-start
+
+Important behaviors:
+  System will switch when the current process is FINISHED or ISSUES AN IO
+  After IOs, the process issuing the IO will run LATER (when it is its turn)
+```
+
+What do you think the execution trace will look like? Let's find out:
+
+```text
+prompt> ./process-run.py -l 3:0 -L 5 -c
+Time     PID: 0        CPU        IOs
+  1  RUN:io-start          1
+  2     WAITING                     1
+  3     WAITING                     1
+  4     WAITING                     1
+  5     WAITING                     1
+  6* RUN:io-start          1
+  7     WAITING                     1
+  8     WAITING                     1
+  9     WAITING                     1
+ 10     WAITING                     1
+ 11* RUN:io-start          1
+ 12     WAITING                     1
+ 13     WAITING                     1
+ 14     WAITING                     1
+ 15     WAITING                     1
+ 16*       DONE
+```
+
+As you can see, the program just issues three I/Os. When each I/O is issued,
+the process moves to a WAITING state, and while the device is busy servicing
+the I/O, the CPU is idle.
+
+Let's print some stats (run the same command as above, but with the `-p flag)
+to see some overall behaviors:
+
+```text
+...
+Stats: Total Time 16
+Stats: CPU Busy 3 (18.75%)
+Stats: IO Busy  12 (75.00%)
+```
+
+As you can see, the trace took 16 clock ticks to run, but the CPU was only
+busy less than 20% of the time. The IO device, on the other hand, was quite
+busy. In general, we'd like to keep all the devices busy, as that is a better
+use of resources.
+
+There are a few other important flags:
+
+* `-s SEED, --seed=SEED`  the random seed
+
+ this gives you way to create a bunch of different jobs randomly
+
+* `-L IO_LENGTH, --iolength=IO_LENGTH`
+
+  this determines how long IOs take to complete (default is 5 ticks)
+
+* `-S PROCESS_SWITCH_BEHAVIOR, --switch=PROCESS_SWITCH_BEHAVIOR` when to switch between processes: `SWITCH_ON_IO, SWITCH_ON_END`
+
+  this determines when we switch to another process:
+    -  `SWITCH_ON_IO`, the system will switch when a process issues an IO
+    -  `SWITCH_ON_END`, the system will only switch when the current process is done
+
+* `-I IO_DONE_BEHAVIOR, --iodone=IO_DONE_BEHAVIOR` type of behavior when IO ends: `IO_RUN_LATER`, `IO_RUN_IMMEDIATE`
+
+  this determines when a process runs after it issues an IO:
+    -  `IO_RUN_IMMEDIATE`: switch to this process right now
+    -  `IO_RUN_LATER`: switch to this process when it is natural to
+      (e.g., depending on process-switching behavior)

hw1/simu1/process-run.py

@@ -0,0 +1,325 @@
+#! /usr/bin/env python
+
+import sys
+from optparse import OptionParser
+import random
+
+# process switch behavior
+SCHED_SWITCH_ON_IO = 'SWITCH_ON_IO'
+SCHED_SWITCH_ON_END = 'SWITCH_ON_END'
+
+# io finished behavior
+IO_RUN_LATER = 'IO_RUN_LATER'
+IO_RUN_IMMEDIATE = 'IO_RUN_IMMEDIATE'
+
+# process states
+STATE_RUNNING = 'RUNNING'
+STATE_READY = 'READY'
+STATE_DONE = 'DONE'
+STATE_WAIT = 'WAITING'
+
+# members of process structure
+PROC_CODE = 'code_'
+PROC_PC = 'pc_'
+PROC_ID = 'pid_'
+PROC_STATE = 'proc_state_'
+
+# things a process can do
+DO_COMPUTE = 'cpu'
+DO_IO = 'io'
+
+
+class scheduler:
+    def __init__(self, process_switch_behavior, io_done_behavior, io_length):
+        # keep set of instructions for each of the processes
+        self.proc_info = {}
+        self.process_switch_behavior = process_switch_behavior
+        self.io_done_behavior = io_done_behavior
+        self.io_length = io_length
+        return
+
+    def new_process(self):
+        proc_id = len(self.proc_info)
+        self.proc_info[proc_id] = {}
+        self.proc_info[proc_id][PROC_PC] = 0
+        self.proc_info[proc_id][PROC_ID] = proc_id
+        self.proc_info[proc_id][PROC_CODE] = []
+        self.proc_info[proc_id][PROC_STATE] = STATE_READY
+        return proc_id
+
+    def load_file(self, progfile):
+        fd = open(progfile)
+        proc_id = self.new_process()
+        
+        for line in fd:
+            tmp = line.split()
+            if len(tmp) == 0:
+                continue
+            opcode = tmp[0]
+            if opcode == 'compute':
+                assert(len(tmp) == 2)
+                for i in range(int(tmp[1])):
+                    self.proc_info[proc_id][PROC_CODE].append(DO_COMPUTE)
+            elif opcode == 'io':
+                assert(len(tmp) == 1)
+                self.proc_info[proc_id][PROC_CODE].append(DO_IO)
+        fd.close()
+        return
+
+    def load(self, program_description):
+        proc_id = self.new_process()
+        tmp = program_description.split(':')
+        if len(tmp) != 2:
+            print 'Bad description (%s): Must be number <x:y>' % program_description
+            print '  where X is the number of instructions'
+            print '  and Y is the percent change that an instruction is CPU not IO'
+            exit(1)
+
+        num_instructions, chance_cpu = int(tmp[0]), float(tmp[1])/100.0
+        for i in range(num_instructions):
+            if random.random() < chance_cpu:
+                self.proc_info[proc_id][PROC_CODE].append(DO_COMPUTE)
+            else:
+                self.proc_info[proc_id][PROC_CODE].append(DO_IO)
+        return
+
+    def move_to_ready(self, expected, pid=-1):
+        if pid == -1:
+            pid = self.curr_proc
+        assert(self.proc_info[pid][PROC_STATE] == expected)
+        self.proc_info[pid][PROC_STATE] = STATE_READY
+        return
+
+    def move_to_wait(self, expected):
+        assert(self.proc_info[self.curr_proc][PROC_STATE] == expected)
+        self.proc_info[self.curr_proc][PROC_STATE] = STATE_WAIT
+        return
+
+    def move_to_running(self, expected):
+        assert(self.proc_info[self.curr_proc][PROC_STATE] == expected)
+        self.proc_info[self.curr_proc][PROC_STATE] = STATE_RUNNING
+        return
+
+    def move_to_done(self, expected):
+        assert(self.proc_info[self.curr_proc][PROC_STATE] == expected)
+        self.proc_info[self.curr_proc][PROC_STATE] = STATE_DONE
+        return
+
+    def next_proc(self, pid=-1):
+        if pid != -1:
+            self.curr_proc = pid
+            self.move_to_running(STATE_READY)
+            return
+        for pid in range(self.curr_proc + 1, len(self.proc_info)):
+            if self.proc_info[pid][PROC_STATE] == STATE_READY:
+                self.curr_proc = pid
+                self.move_to_running(STATE_READY)
+                return
+        for pid in range(0, self.curr_proc + 1):
+            if self.proc_info[pid][PROC_STATE] == STATE_READY:
+                self.curr_proc = pid
+                self.move_to_running(STATE_READY)
+                return
+        return
+
+    def get_num_processes(self):
+        return len(self.proc_info)
+
+    def get_num_instructions(self, pid):
+        return len(self.proc_info[pid][PROC_CODE])
+
+    def get_instruction(self, pid, index):
+        return self.proc_info[pid][PROC_CODE][index]
+
+    def get_num_active(self):
+        num_active = 0
+        for pid in range(len(self.proc_info)):
+            if self.proc_info[pid][PROC_STATE] != STATE_DONE:
+                num_active += 1
+        return num_active
+
+    def get_num_runnable(self):
+        num_active = 0
+        for pid in range(len(self.proc_info)):
+            if self.proc_info[pid][PROC_STATE] == STATE_READY or \
+                   self.proc_info[pid][PROC_STATE] == STATE_RUNNING:
+                num_active += 1
+        return num_active
+
+    def get_ios_in_flight(self, current_time):
+        num_in_flight = 0
+        for pid in range(len(self.proc_info)):
+            for t in self.io_finish_times[pid]:
+                if t > current_time:
+                    num_in_flight += 1
+        return num_in_flight
+
+    def check_for_switch(self):
+        return
+
+    def space(self, num_columns):
+        for i in range(num_columns):
+            print '%10s' % ' ',
+
+    def check_if_done(self):
+        if len(self.proc_info[self.curr_proc][PROC_CODE]) == 0:
+            if self.proc_info[self.curr_proc][PROC_STATE] == STATE_RUNNING:
+                self.move_to_done(STATE_RUNNING)
+                self.next_proc()
+        return
+
+    def run(self):
+        clock_tick = 0
+
+        if len(self.proc_info) == 0:
+            return
+
+        # track outstanding IOs, per process
+        self.io_finish_times = {}
+        for pid in range(len(self.proc_info)):
+            self.io_finish_times[pid] = []
+
+        # make first one active
+        self.curr_proc = 0
+        self.move_to_running(STATE_READY)
+
+        # OUTPUT: headers for each column
+        print '%s' % 'Time', 
+        for pid in range(len(self.proc_info)):
+            print '%10s' % ('PID:%2d' % (pid)),
+        print '%10s' % 'CPU',
+        print '%10s' % 'IOs',
+        print ''
+
+        # init statistics
+        io_busy = 0
+        cpu_busy = 0
+
+        while self.get_num_active() > 0:
+            clock_tick += 1
+
+            # check for io finish
+            io_done = False
+            for pid in range(len(self.proc_info)):
+                if clock_tick in self.io_finish_times[pid]:
+                    io_done = True
+                    self.move_to_ready(STATE_WAIT, pid)
+                    if self.io_done_behavior == IO_RUN_IMMEDIATE:
+                        # IO_RUN_IMMEDIATE
+                        if self.curr_proc != pid:
+                            if self.proc_info[self.curr_proc][PROC_STATE] == STATE_RUNNING:
+                                self.move_to_ready(STATE_RUNNING)
+                        self.next_proc(pid)
+                    else:
+                        # IO_RUN_LATER
+                        if self.process_switch_behavior == SCHED_SWITCH_ON_END and self.get_num_runnable() > 1:
+                            # this means the process that issued the io should be run
+                            self.next_proc(pid)
+                        if self.get_num_runnable() == 1:
+                            # this is the only thing to run: so run it
+                            self.next_proc(pid)
+                    self.check_if_done()
+            
+            # if current proc is RUNNING and has an instruction, execute it
+            instruction_to_execute = ''
+            if self.proc_info[self.curr_proc][PROC_STATE] == STATE_RUNNING and \
+                   len(self.proc_info[self.curr_proc][PROC_CODE]) > 0:
+                instruction_to_execute = self.proc_info[self.curr_proc][PROC_CODE].pop(0)
+                cpu_busy += 1
+
+            # OUTPUT: print what everyone is up to
+            if io_done:
+                print '%3d*' % clock_tick,
+            else:
+                print '%3d ' % clock_tick,
+            for pid in range(len(self.proc_info)):
+                if pid == self.curr_proc and instruction_to_execute != '':
+                    print '%10s' % ('RUN:'+instruction_to_execute),
+                else:
+                    print '%10s' % (self.proc_info[pid][PROC_STATE]),
+            if instruction_to_execute == '':
+                print '%10s' % ' ',
+            else:
+                print '%10s' % 1,
+            num_outstanding = self.get_ios_in_flight(clock_tick)
+            if num_outstanding > 0:
+                print '%10s' % str(num_outstanding),
+                io_busy += 1
+            else:
+                print '%10s' % ' ',
+            print ''
+
+            # if this is an IO instruction, switch to waiting state
+            # and add an io completion in the future
+            if instruction_to_execute == DO_IO:
+                self.move_to_wait(STATE_RUNNING)
+                self.io_finish_times[self.curr_proc].append(clock_tick + self.io_length)
+                if self.process_switch_behavior == SCHED_SWITCH_ON_IO:
+                    self.next_proc()
+
+            # ENDCASE: check if currently running thing is out of instructions
+            self.check_if_done()
+        return (cpu_busy, io_busy, clock_tick)
+        
+#
+# PARSE ARGUMENTS
+#
+
+parser = OptionParser()
+parser.add_option('-s', '--seed', default=0, help='the random seed', action='store', type='int', dest='seed')
+parser.add_option('-l', '--processlist', default='',
+                  help='a comma-separated list of processes to run, in the form X1:Y1,X2:Y2,... where X is the number of instructions that process should run, and Y the chances (from 0 to 100) that an instruction will use the CPU or issue an IO',
+                  action='store', type='string', dest='process_list')
+parser.add_option('-L', '--iolength', default=5, help='how long an IO takes', action='store', type='int', dest='io_length')
+parser.add_option('-S', '--switch', default='SWITCH_ON_IO',
+                  help='when to switch between processes: SWITCH_ON_IO, SWITCH_ON_END',
+                  action='store', type='string', dest='process_switch_behavior')
+parser.add_option('-I', '--iodone', default='IO_RUN_LATER',
+                  help='type of behavior when IO ends: IO_RUN_LATER, IO_RUN_IMMEDIATE',
+                  action='store', type='string', dest='io_done_behavior')
+parser.add_option('-c', help='compute answers for me', action='store_true', default=False, dest='solve')
+parser.add_option('-p', '--printstats', help='print statistics at end; only useful with -c flag (otherwise stats are not printed)', action='store_true', default=False, dest='print_stats')
+(options, args) = parser.parse_args()
+
+random.seed(options.seed)
+
+assert(options.process_switch_behavior == SCHED_SWITCH_ON_IO or \
+       options.process_switch_behavior == SCHED_SWITCH_ON_END)
+assert(options.io_done_behavior == IO_RUN_IMMEDIATE or \
+       options.io_done_behavior == IO_RUN_LATER)
+
+s = scheduler(options.process_switch_behavior, options.io_done_behavior, options.io_length)
+
+# example process description (10:100,10:100)
+for p in options.process_list.split(','):
+    s.load(p)
+
+if options.solve == False:
+    print 'Produce a trace of what would happen when you run these processes:'
+    for pid in range(s.get_num_processes()):
+        print 'Process %d' % pid
+        for inst in range(s.get_num_instructions(pid)):
+            print '  %s' % s.get_instruction(pid, inst)
+        print ''
+    print 'Important behaviors:'
+    print '  System will switch when',
+    if options.process_switch_behavior == SCHED_SWITCH_ON_IO:
+        print 'the current process is FINISHED or ISSUES AN IO'
+    else:
+        print 'the current process is FINISHED'
+    print '  After IOs, the process issuing the IO will',
+    if options.io_done_behavior == IO_RUN_IMMEDIATE:
+        print 'run IMMEDIATELY'
+    else:
+        print 'run LATER (when it is its turn)'
+    print ''
+    exit(0)
+
+(cpu_busy, io_busy, clock_tick) = s.run()
+
+if options.print_stats:
+    print ''
+    print 'Stats: Total Time %d' % clock_tick
+    print 'Stats: CPU Busy %d (%.2f%%)' % (cpu_busy, 100.0 * float(cpu_busy)/clock_tick)
+    print 'Stats: IO Busy  %d (%.2f%%)' % (io_busy, 100.0 * float(io_busy)/clock_tick)
+    print ''

hw1/simu2/QUESTIONS.md

@@ -0,0 +1,18 @@
+# Questions 4-Process-Run Simulation Part 2
+
+This program, `process-run.py`, allows you to see how process states change as programs run and either use the CPU (e.g., perform an add instruction) or do I/O (e.g., send a request to a disk and wait for it to complete). See the README for details.
+
+Please answer the questions, by giving the result and an explanation, why you got the result. Sometimes it could be helpful, if you compare your result with results of earlier questions. Write your answers in markdown syntax in the new file `ANSWERS.md.`
+
+
+1. One  important behavior is what to do when an I/O completes. With `-I IO_RUN_LATER`, when an I/O completes, the process that issued it is not necessarily run right away; rather, whatever was running at the time keeps running. What happens when you run this combination of processes?
+
+ ```text
+./process-run.py -l 3:0,5:100,5:100,5:100 -S SWITCH ON IO -I IO RUN LATER -c -p
+ ```
+
+ Are system resources being effectively utilized?
+
+2. Now run the same processes, but with `-I IO_RUN_IMMEDIATE` set, which immediately runs the process that issued the I/O. How does this behavior differ? Why might running a process that just completed an I/O again be a good idea?
+
+3. Now run with some randomly generated processes, e.g., `-s 1 -l 3:50,3:50, -s 2 -l 3:50,3:50, -s 3 -l 3:50,3:50`. See if you can predict how the trace will turn out. What happens when you use `-I IO_RUN_IMMEDIATE` vs. `-I IO_RUN_LATER`? What happens when you use `-S SWITCH_ON_IO` vs. `-S SWITCH_ON_END`?

hw1/task1/README.md

@@ -0,0 +1,31 @@
+# Homework hw1 task 1
+
+## Vorbereitungen
+
+Rufen Sie im `task1/` Verzeichnis: `cargo init` auf. Dadurch wird ein Rust Library Projekt in `task1/` angelegt. Mit `cargo build` wird die Library erstellt, der Aufruf `cargo test` ruft die CI Tests im `tests/` Verzeichnis auf und testet Ihre Library.
+
+## task
+
+Schreiben Sie die Funktion
+
+```rust
+pub fn is_leap_year(year: i32) -> bool
+```
+
+die überprüft, ob das übergebene Jahr ein Schaltjahr ist.
+
+Das trickreiche an der Überprüfung ist, dass folgende Bedingungen für das Jahr gelten müssen:
+
+```plain
+on every year that is evenly divisible by 4
+  except every year that is evenly divisible by 100
+    unless the year is also evenly divisible by 400
+```
+
+Zum Beispiel ist 1997 kein Schaltjahr, aber 1996. 1900 ist kein Schaltjahr aber 2000.
+
+Verwenden Sie keine Funktionen aus Bibliotheken dafür, sondern implementieren Sie die Funktion selbst.
+
+## Test
+
+Testen können Sie Ihre Library durch den Aufruf von `cargo test`. Dann werden alle Tests aus der Datei `tests/task1.rs` ausgeführt.

hw1/task1/src/lib.rs

@@ -0,0 +1,3 @@
+pub fn is_leap_year(year: i32) -> bool {
+    unimplemented!();
+}

hw1/task1/tests/task1.rs

@@ -0,0 +1,25 @@
+extern crate task1;
+
+#[test]
+fn test_vanilla_leap_year() {
+    assert_eq!(task1::is_leap_year(1996), true);
+}
+
+#[test]
+fn test_any_old_year() {
+    assert_eq!(task1::is_leap_year(1995), false);
+    assert_eq!(task1::is_leap_year(1997), false);
+    assert_eq!(task1::is_leap_year(1998), false);
+    assert_eq!(task1::is_leap_year(1999), false);
+}
+
+#[test]
+fn test_century() {
+    assert_eq!(task1::is_leap_year(1900), false);
+}
+
+#[test]
+fn test_exceptional_centuries() {
+    assert_eq!(task1::is_leap_year(2000), true);
+    assert_eq!(task1::is_leap_year(2400), true);
+}

hw1/task2/README.md

@@ -0,0 +1,24 @@
+# Homework hw1 task 2
+
+## prepare your task
+
+Run `cargo init` in your `task2/` directory.
+
+## task
+
+Calculate the number of grains of wheat on a chessboard given that the number on each square doubles.
+
+There once was a wise servant who saved the life of a prince. The king
+promised to pay whatever the servant could dream up. Knowing that the
+king loved chess, the servant told the king he would like to have grains
+of wheat. One grain on the first square of a chess board. Two grains on
+the next. Four on the third, and so on.
+
+There are 64 squares on a chessboard.
+
+Write code that shows:
+
+- how many grains were on each square (`fn square(n: u32) -> u64`), and
+- the total number of grains (`fn total() -> u64`)
+
+Use the given file `lib.rs` for your solution.

hw1/task2/src/lib.rs

@@ -0,0 +1,8 @@
+pub fn square(n: u32) -> u64 {
+    unimplemented!()
+}
+
+
+pub fn total() -> u64 {
+    unimplemented!();
+}

hw1/task2/tests/task2.rs

@@ -0,0 +1,41 @@
+extern crate task2;
+
+#[test]
+fn square_one() {
+    assert_eq!(task2::square(1), 1);
+}
+
+#[test]
+fn square_two() {
+    assert_eq!(task2::square(2), 2);
+}
+
+#[test]
+fn square_three() {
+    assert_eq!(task2::square(3), 4);
+}
+
+#[test]
+fn square_four() {
+    assert_eq!(task2::square(4), 8);
+}
+
+#[test]
+fn square_sixteen() {
+    assert_eq!(task2::square(16), 32_768);
+}
+
+#[test]
+fn square_thirty_two() {
+    assert_eq!(task2::square(32), 2_147_483_648);
+}
+
+#[test]
+fn square_sixty_four() {
+    assert_eq!(task2::square(64), 9_223_372_036_854_775_808);
+}
+
+#[test]
+fn total_sums_all_squares() {
+    assert_eq!(task2::total(), 18_446_744_073_709_551_615);
+}

hw1/task3/README.md

@@ -0,0 +1,8 @@
+# Homework hw1 task 3
+
+## prepare your task
+
+Run `cargo init` in your `task3/` directory.
+
+## task
+Schreiben Sie eine Funktion `count(line: &str, c: char) -> u64)` welche zählt, wie oft ein gegebenes Zeichen (c) in einem gegebenen String (line) vorkommt und diese Anzahl zurück gibt. Z.B. soll der Aufruf `count("peter", 'e')` `2` zurückgeben.

hw1/task3/src/lib.rs

@@ -0,0 +1,3 @@
+pub fn count(line: &str, c: char) -> u64 {
+    unimplemented!();
+}

hw1/task3/tests/task3.rs

@@ -0,0 +1,45 @@
+extern crate task3;
+
+#[test]
+fn test_one_char() {
+    assert_eq!(
+        task3::count("♥ The quick brown fox jumps over the lazy dog. ♥", 'T'),
+        1
+    );
+}
+
+#[test]
+fn test_two_char() {
+    assert_eq!(
+        task3::count(
+            "♥ The quick brown fox jumps over the lazy dog. ♥",
+            '♥',
+        ),
+        2
+    );
+}
+
+#[test]
+#[should_panic]
+fn test_wrong() {
+    assert_eq!(
+        task3::count("♥ The quick brown fox jumps over the lazy dog. ♥", 'c'),
+        2
+    );
+}
+
+#[test]
+fn test_four_char() {
+    assert_eq!(
+        task3::count("♥ The quick brown fox jumps over the lazy dog. ♥", 'o'),
+        4
+    );
+}
+
+#[test]
+fn test_no_char() {
+    assert_eq!(
+        task3::count("♥ The quick brown fox jumps over the lazy dog. ♥", '!'),
+        0
+    );
+}

hw1/task4/README.md

@@ -0,0 +1,22 @@
+# Homework hw1 task 4
+
+## prepare your task
+
+Run `cargo init` in your `task4/` directory.
+
+## task
+
+Find the difference between the sum of the squares and the square of the sum of the first N natural numbers.
+
+The square of the sum of the first ten natural numbers is,
+
+    (1 + 2 + ... + 10)**2 = 55**2 = 3025
+
+The sum of the squares of the first ten natural numbers is,
+
+    1**2 + 2**2 + ... + 10**2 = 385
+
+Hence the difference between the square of the sum of the first
+ten natural numbers and the sum of the squares is 2640:
+
+    3025 - 385 = 2640

hw1/task4/src/lib.rs

@@ -0,0 +1,11 @@
+pub fn square_of_sum(n: i32) -> i32 {
+    unimplemented!();
+}
+
+pub fn sum_of_squares(n: i32) -> i32 {
+    unimplemented!();
+}
+
+pub fn difference(n: i32) -> i32 {
+    unimplemented!();
+}

hw1/task4/tests/task4.rs

@@ -0,0 +1,31 @@
+extern crate task4;
+
+#[test]
+fn test_square_of_sum_5() {
+    assert_eq!(225, task4::square_of_sum(5));
+}
+
+#[test]
+fn test_sum_of_squares_5() {
+    assert_eq!(55, task4::sum_of_squares(5));
+}
+
+#[test]
+fn test_difference_5() {
+    assert_eq!(170, task4::difference(5));
+}
+
+#[test]
+fn test_square_of_sum_100() {
+    assert_eq!(25502500, task4::square_of_sum(100));
+}
+
+#[test]
+fn test_sum_of_squares_100() {
+    assert_eq!(338350, task4::sum_of_squares(100));
+}
+
+#[test]
+fn test_difference_100() {
+    assert_eq!(25164150, task4::difference(100));
+}

hw1/task5/README.md

@@ -0,0 +1,32 @@
+# Homework hw1 task 5
+
+## Vorbereitungen
+
+Rufen Sie im `task5/` Verzeichnis: `cargo init --bin` auf. Dadurch wird ein Rust Binary Projekt in `task5/` angelegt. Mit `cargo build` wird die Library erstellt, der Aufruf `cargo run` startet das Programm. Der Aufruf von `cargo test` ruft die UNIT-Tests im `src/main.rs` auf.
+
+Ausserdem können die korrekten Outputs Ihres Programms auf der Console mit dem Aufruf von `bats tests/output.bats` getestet werden.
+
+## task
+
+Schreiben Sie ein Programm, in welchem eine von Ihnen selbst geschriebene Funktion
+
+```rust
+fn is_prime(n: u64) -> bool
+```
+
+genutzt wird, die überprüft, ob eine gegebene Zahl eine Primzahl ist. Die Funktion muss nicht auf Laufzeit optimiert werden.
+
+Die *main()* Funktion gibt in einer Schleife die Zahlen von 1 bis 30 aus. Die Zahlen, die eine Primzahlt sind werden in der Ausgabe mit einem `*`` Zeichen markiert.
+
+```
+1
+2*
+3*
+4
+5*
+...
+```
+
+Nutzen Sie die schon vorgegebene Datei `main.rs`!
+
+Verwenden Sie keine Funktionen aus Bibliotheken dafür, sondern implementieren Sie die Funktion selbst.

hw1/task5/src/main.rs

@@ -0,0 +1,40 @@
+//! hw01t5: Primzahltest
+fn is_prime(n: u64) -> bool {
+    unimplemented!();
+}
+
+
+fn main() {
+    unimplemented!();
+}
+
+#[test]
+fn small_primes() {
+    assert!(is_prime(2));
+    assert!(is_prime(3));
+    assert!(is_prime(5));
+    assert!(is_prime(7));
+}
+
+#[test]
+fn small_composites() {
+    assert!(!is_prime(1));
+    assert!(!is_prime(4));
+    assert!(!is_prime(6));
+    assert!(!is_prime(8));
+    assert!(!is_prime(9));
+}
+
+#[test]
+fn large_primes() {
+    assert!(is_prime(1_300_769));
+    assert!(is_prime(1_300_297));
+    assert!(is_prime(7_367_287));
+}
+
+#[test]
+fn large_composites() {
+    assert!(!is_prime(908_209));
+    assert!(!is_prime(3_073_009));
+    assert!(!is_prime(4_897_369));
+}

hw1/task5/tests/output.bats

@@ -0,0 +1,27 @@
+#!/usr/bin/env bats
+
+
+@test "Check that we have a debug output" {
+    run stat "$BATS_TEST_DIRNAME/../target/debug/task5"
+    [ "$status" -eq 0 ]
+}
+
+@test "Output must be from 1..30 and correct formated" {
+    run "$BATS_TEST_DIRNAME/../target/debug/task5"
+    [[ "${lines[0]}" =~ "1" ]]
+    [[ "${lines[1]}" =~ "2*" ]]
+    [[ "${lines[2]}" =~ "3*" ]]
+    [[ "${lines[3]}" =~ "4" ]]
+    [[ "${lines[4]}" =~ "5" ]]
+    [[ "${lines[25]}" =~ "26" ]]
+    [[ "${lines[26]}" =~ "27" ]]
+    [[ "${lines[27]}" =~ "28" ]]
+    [[ "${lines[28]}" =~ "29*" ]]
+    [[ "${lines[29]}" =~ "30" ]]
+}
+
+# wc output with white spaces is trimmed by xargs
+@test "Output must be exact 30 lines long" {
+    run bash -c "'$BATS_TEST_DIRNAME/../target/debug/task5' | wc -l | xargs"
+    [ "$output" = "30" ]
+}

hw2/README.md

@@ -0,0 +1,40 @@
+# hw2
+
+## Tasks
+
+To fullfill **hw2** you have to solve:
+
+- task1
+- task2
+- simu1
+
+Optional are (bonus +1P):
+
+- task3 (important: Rust idiomatic code please)
+
+## Files
+
+You find already files for each rust task. Please remember to use cargo to
+create the relevant projects for each task.
+
+## ASIDE: `simu1/` dir
+
+In this homework it's not a simulation homework sitting in `simu1/` but some
+questions to have fun with buggy c-files. As not to interfer with rust code,
+questions, c-code and your answers should go into `simu1/`.
+
+## 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 **hw2**.
+
+## Gradings of hw2
+
+| Task     | max. Credits | Comment |
+| -------- | ------------ | ------- |
+| task1    | 1            |         |
+| task2    | 2            |         |
+| task3    | +1           |         |
+| simu1    | 1            |         |
+| Deadline | +1           |         |
+| =        | 6            |         |

hw2/simu1/ANSWERS.md

@@ -0,0 +1,9 @@
+## Antworten zur Simulation 1 (hw2)
+
+1. Beim Ausführen stürzt das Programm mit der Fehlermeldung `Segmentation Fault` ab.
+2. GDB gibt den Hinweis `Program received signal SIGSEGV, Segmentation fault.` aus.
+3. Valgrind zeigt den Fehler `Invalid Read` und sowohl die Adresse im Speicher als auch die Zeile im Code, in der der Fehler auftritt. Das bedeutet, dass auf eine undefinierte Adresse zugegriffen wird. Da die Zeile im Code auch ausgegeben wird, lässt sich der Ursprung des Fehlers leicht eingrenzen.
+4. Das Programm `malloc` erzeugt keine Ausgabe und crasht nicht. GDB bestätigt das: `Inferior 1 (process 2982) exited normally`. Mithilfe von Valgrind sehen wir, dass 10 Bytes nicht freigegeben wurden: `LEAK SUMMARY: definitely lost: 10 bytes in 1 blocks`.
+5.
+6. Das Programm (`intArray2`) gibt den Wert `0` aus und läuft ohne Fehler. Valgrind weist uns auf einen `invalid read` an der betreffenden Stelle hin.
+

hw2/simu1/Makefile

@@ -0,0 +1,11 @@
+CC=gcc
+CFLAGS=-g
+RM=rm -f
+TARGET=null malloc intArray1 intArray2 free
+.PHONY: all clean
+all: $(TARGET)
+clean:
+	$(RM) null malloc intArray1 intArray2 free
+
+$(TARGET): $(TARGET).c
+	$(CC) $< $(CFLAGS) -o $@

hw2/simu1/QUESTIONS.md

@@ -0,0 +1,72 @@
+# Questions 14-Memory-API
+
+## Overview
+
+In this task, you will gain some familiarity with memory allocation. First,
+you’ll write some buggy programs (fun!). Then, you’ll use some tools to help you
+find the bugs you inserted. Then, you will realize how awesome these tools are
+and use them in the future, thus making yourself more happy and productive.
+
+The first tool you’ll use is **gdb**, the debugger. There is a lot to learn
+about this debugger; here we’ll only scratch the surface. Here you can find a
+[quick reference gdb][]. Also **ddd** is installed on lab workstations.
+
+The second tool you’ll use is [valgrind][]. This tool helps find memory leaks
+and other insidious memory problems in your program.
+
+Please answer the questions, by giving the result and an explanation, why you
+got the result.  Write your answers in markdown syntax in the new file
+`ANSWERS.md`. Also checkin your C-Files and one Makefile for all or your
+C-Files, so that all binaries are build. Do NOT checkin the binaries!
+
+The installed gcc wrapper on you workstations does some optimization to your code
+examples, which will not show some of the bugs with an "Segmentation fault". We
+have already disabled this behavior by setting:
+
+```text
+export hardeningDisable=all
+```
+
+in your labshell bsys environment. So, you don't have to do any further steps to
+produce unoptimized code with gcc, if you want to.
+
+If you struggle with your own systems about some strange gcc optimization
+behavior, maybe it helps to check for gcc-wrapper variables like these.
+
+## Questions
+
+1. First, write a simple program called `null.c` that creates a pointer to an
+   integer, sets it to `NULL`, and then tries to dereference it. Compile this
+   into an executable called **null**. What happens when you run this program?
+
+1. Next, compile this program with symbol information included (with the `-g`
+   flag). Doing so let’s put more information into the executable, enabling the
+   debugger to access more useful information about variable names and the like.
+   Run the program under the debugger by typing `gdb null` and then, once gdb is
+   running, typing `run`. What does gdb show you?
+
+1. Finally, use the valgrind tool on this program. We’ll use the memcheck tool
+   that is a part of valgrind to analyze what happens. Run this by typing in the
+   following: `valgrind --leak-check=yes ./null`. What happens when you run
+   this? Can you interpret the output from the tool?
+
+1. Write a simple program that allocates memory using `malloc()` but forgets to
+   free it before exiting. What happens when this program runs? Can you use
+   `gdb` to find any problems with it? How about `valgrind` (again with the
+   `--leak-check=yes` flag)?
+
+1. Write a program that creates an array of integers of size 100 using
+   `malloc()`; then, set `data[100]` to zero. What happens when you run this
+   program? What happens when you run this program using `valgrind`? Is the
+   program correct?
+
+1. Create a program that allocates an array of integers (as above),frees them,
+   and then tries to print the value of one of the elements of the array. Does
+   the program run? What happens when you use `valgrind` on it?
+
+1. Now pass a funny value to free (e.g., a pointer in the middle of the array
+   you allocated above). What happens? Do you need tools to find this type of
+   problem?
+
+[valgrind]: http://valgrind.org/downloads/current.html
+[quick reference gdb]: https://web.stanford.edu/class/cs107/gdb_refcard.pdf

hw2/simu1/free.c

@@ -0,0 +1,7 @@
+/* free.c */
+#include <stdlib.h>
+int main(char* argv[], int argc) {
+  char* testString = malloc(10 * sizeof(char));
+  free(testString[10]);
+  free(testString);
+}

hw2/simu1/intArray1.c

@@ -0,0 +1,7 @@
+/* intArray1.c */
+#include <stdlib.h>
+int main(char* argv[], int argc) {
+  int* intArray = malloc(100 * sizeof(int));
+  intArray[100] = 0;
+  free(intArray);
+}

hw2/simu1/intArray2.c

@@ -0,0 +1,8 @@
+/* intArray2.c */
+#include <stdlib.h>
+#include <stdio.h>
+int main(char* argv[], int argc) {
+  int* intArray = malloc(100 * sizeof(int));
+  free(intArray);
+  printf("%d", intArray[10]);
+}

hw2/simu1/malloc.c

@@ -0,0 +1,5 @@
+/* malloc.c */
+#include <stdlib.h>
+int main(char* argv[], int argc) {
+  char* testString = malloc(sizeof(char) * 10);
+}

hw2/simu1/null.c

@@ -0,0 +1,12 @@
+#include <stdlib.h>
+#include <stdio.h>
+int main(char* argv[], int argc)
+{
+  int i, j;
+  int* iPointer;
+
+  i = 10;
+  iPointer = &i;
+  iPointer = NULL;
+  j = *iPointer;
+}

hw2/task1/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "task1"
+version = "0.1.0"
+authors = ["Lorenz Bung <lorenz.bung@googlemail.com>"]
+
+[dependencies]

hw2/task1/README.md

@@ -0,0 +1,38 @@
+# Homework hw2 task1
+
+## prepare your task
+
+Run the cargo command to prepare your task1/ directory as a library
+
+## task
+
+Calculate the Hamming difference between two DNA strands by implementing the
+library function *hamming_distance(s1: &str, s2: &str) -> Result<usize,
+String>*. Do not use any crates.
+
+A mutation is simply a mistake that occurs during the creation or copying of a
+nucleic acid, in particular DNA. Because nucleic acids are vital to cellular
+functions, mutations tend to cause a ripple effect throughout the cell. Although
+mutations are technically mistakes, a very rare mutation may equip the cell with
+a beneficial attribute. In fact, the macro effects of evolution are attributable
+by the accumulated result of beneficial microscopic mutations over many
+generations.
+
+The simplest and most common type of nucleic acid mutation is a point mutation,
+which replaces one base with another at a single nucleotide.
+
+By counting the number of differences between two homologous DNA strands taken
+from different genomes with a common ancestor, we get a measure of the minimum
+number of point mutations that could have occurred on the evolutionary path
+between the two strands.
+
+This is called the 'Hamming distance'.
+
+It is found by comparing two DNA strands and counting how many of the
+nucleotides are different from their equivalent in the other string.
+
+    GAGCCTACTAACGGGAT
+    CATCGTAATGACGGCCT
+    ^ ^ ^  ^ ^    ^^
+
+The Hamming distance between these two DNA strands is 7.

hw2/task1/src/lib.rs

@@ -0,0 +1,22 @@
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+}
+pub fn hamming_distance(s1: &str, s2: &str) -> Result<usize, String> {
+    //Check if the given Strings are of different length
+    if s1.len() != s2.len() {
+        return Err("Strings must be of equal length!".to_string());
+    }
+    let mut dist: usize = 0;
+    for i in 0..s1.len() {
+        //Compare each character of the Strings
+        if s1.chars().nth(i) != s2.chars().nth(i) {
+            //If they don't match, increment hamming distance
+            dist += 1
+        }
+    }
+    Ok(dist)
+}

hw2/task1/tests/task1.rs

@@ -0,0 +1,36 @@
+extern crate task1;
+
+#[test]
+fn test_no_difference_between_empty_strands() {
+    assert_eq!(task1::hamming_distance("", "").unwrap(), 0);
+}
+
+#[test]
+fn test_no_difference_between_identical_strands() {
+    assert_eq!(task1::hamming_distance("GGACTGA", "GGACTGA").unwrap(), 0);
+}
+
+#[test]
+fn test_complete_hamming_distance_in_small_strand() {
+    assert_eq!(task1::hamming_distance("ACT", "GGA").unwrap(), 3);
+}
+
+#[test]
+fn test_small_hamming_distance_in_the_middle_somewhere() {
+    assert_eq!(task1::hamming_distance("GGACG", "GGTCG").unwrap(), 1);
+}
+
+#[test]
+fn test_larger_distance() {
+    assert_eq!(task1::hamming_distance("ACCAGGG", "ACTATGG").unwrap(), 2);
+}
+
+#[test]
+fn test_first_string_is_longer() {
+    assert!(task1::hamming_distance("AAA", "AA").is_err());
+}
+
+#[test]
+fn test_second_string_is_longer() {
+    assert!(task1::hamming_distance("A", "AA").is_err());
+}

hw2/task2/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "task2"
+version = "0.1.0"
+authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
+
+[dependencies]
+
+[[bin]]
+doc = false
+name = "task2"

hw2/task2/README.md

@@ -0,0 +1,317 @@
+# Homework hw2 task2
+
+- [Überblick](#%C3%BCberblick)
+- [Vorbereitung](#vorbereitung)
+- [Struktur](#struktur)
+- [Funktionen](#funktionen)
+    - [Programmargumente in Rust](#programmargumente-in-rust)
+        - [Warmup Übung](#warmup-%C3%BCbung)
+    - [Argumente parsen](#argumente-parsen)
+        - [Parsen ohne Fehlerbehandlung](#parsen-ohne-fehlerbehandlung)
+        - [Parsen mit Fehlerbehandlung](#parsen-mit-fehlerbehandlung)
+    - [Zeichen im String suchen](#zeichen-im-string-suchen)
+    - [Ablauf des Programms](#ablauf-des-programms)
+        - [Dead Code](#dead-code)
+- [Restructuring](#restructuring)
+    - [Parsen der Config als Methode](#parsen-der-config-als-methode)
+    - [Tests](#tests)
+    - [Dokumentation](#dokumentation)
+
+## Überblick
+
+In dieser Aufgabe sollen Sie ein Programm entwickeln, welches 2 Parameter
+übergeben bekommt:
+
+- *1.* übergebene Parameter: Zu suchendes Zeichen
+- *2.* übergebene Parameter: String in dem die Zeichenkette gesucht werden soll.
+
+Das Programm gibt die Anzahl gefundener Treffer aus.
+
+```text
+You asked me to count all 'e' in "♥ The quick brown fox jumps over the lazy dog. ♥"
+Found 3 'e' in "♥ The quick brown fox jumps over the lazy dog. ♥"
+```
+
+Neben einer klaren Struktur für das Programm soll eine kompetente
+Fehlerbehandlung implementiert werden, sodass das Programm robust gegenüber
+Eingebefehlern wird. Benutzen Sie keine weiteren Module aus der Standardbibliothek, ausser:
+
+- std::env
+- std::process
+
+Ziele:
+
+- Parameter einlesen können
+- Weitere String-Funktionen kennen lernen
+- Fehlerbehandlung
+
+## Vorbereitung
+
+Erstellen Sie im `task2/` Ordner mittels cargo ein Binary Projekt.
+
+## Struktur
+
+Das Programm soll aus 3 Funktionen bestehen:
+
+- *main()*
+- *run()*
+- *parse_arguments()*
+
+Die *main()* Funktion ruft zuerst die *parse_arguments()* auf, um danach
+geeignet die *run()* Funktion zum Suchen der Zeichenkette zu starten.
+
+## Funktionen
+
+### Programmargumente in Rust
+
+Bisher waren in Ihren Programmen die Parameter fest codiert. Wie kann man in
+Rust die Parameter beim Aufruf des Programms auswerten?
+
+Dazu existiert das [std::env][std::env] Modul, welches Strukturen und Funktionen
+für die Prozessumgebung (process environment) bereit stellt.
+
+Die Funktion, die die Parameter zur weiteren Auswertung liefert heißt
+[`args()`][args]. Diese Funktion liefert einen Iterator mit Namen [`Arc`][Arc]
+zurück. Was Iteratoren genau sind und was damit alles anzustellen ist werden wir
+später im Semester kennen lernen. Zunächst kann man sich einen Iterator einfach
+als eine 'Datenquelle' vorstellen, die - wenn wir darauf zugreifen - eine Serie
+von Werten liefert. In unserem Fall liefert ein Zugriff auf [`args()`][args] die
+dem Programm übergebenen Parameter als Strings, sofern welche übergeben wurden.
+
+Und damit sind wir auch schon mitten in der Fehlerbehandlung. Auf mögliche
+Fehler wird in der Dokumentation bereits hingewiesen. Wir werden im weiteren von
+UNIX Systemen und korrektem unicode ausgehen, sodass uns ein paar
+Fehlerbehandlungen erspart bleiben.
+
+Um in unserem Programm auf die Parameter zugreifen zu können, werden wir diese
+in einer geeigneten Datentyp speichern. Es bieten sich Arrays oder Vektoren an.
+
+#### Warmup Übung
+
+1. Warum sollten Sie für die Argumente den Datentyp Vector vorziehen?
+1. Schreiben Sie die Funktion:
+
+```rust
+/// Prints elements of Vec
+///
+///
+/// This function will print all elements of Vec with "args found: <elem>" in
+/// each line
+///
+/// Returns nothing
+fn print_arguments(args: &Vec<String>)
+```
+
+Die Funktion gibt den Inhalt des übergeben Vektors zeilenweise aus.
+
+In der Main Funktion lesen Sie die bei Programmstart übergebenen Parameter ein
+und erstellen einen Vektor aus den eingelesenen Parametern, den Sie als Referenz
+übergeben.
+
+> Die Methode [*collect()*][collect] ist Teil des Iterator Traits und bietet
+> sich an um den Vector zu füllen. Überlegen Sie sich auch, warum es sinnvoll
+> ist den Vector an die Funktion *print_arguments* nur zu leihen ('&')?
+
+Wenn Sie nun Ihr Projekt mit `cargo run a b c`starten, so erhalten Sie folgende
+Ausgabe:
+
+```text
+    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
+     Running `target/debug/task1 a b c`
+args found: target/debug/task1
+args found: a
+args found: b
+args found: c
+```
+
+### Argumente parsen
+
+Unsere Argumente speichern wir am Besten in einer eigenen Datenstruktur
+*Config*. Dann sind unsere Parameter als entsprechende Datentypen einfach
+verfügbar.
+
+```rust
+/// a struct to hold all of our configuration
+#[derive(Debug,PartialEq)]
+struct Config{
+    search: char,
+    line: String,
+}
+```
+
+> Mit der *derive* Anweisung lassen wir den Rust Compiler etwas Magie anwenden.
+> Denn durch diese Makro Anweisung erhält unsere Datenstruktur automatisch 2
+> Traits wodurch wiederum automatisch die nötigen Methoden für uns erzeugt
+> werden um unsere Struct zu printen und deren Inhalt vergleichen zu können
+> ("==" Abfrage). Letzteres brauchen wir für die Tests.
+
+#### Parsen ohne Fehlerbehandlung
+
+1. Implementieren Sie die Funktion
+
+```rust
+/// Parses relevant arguments, returning the filled Config
+///
+///
+/// This function will parse the relevant arguments from the
+/// given <Strings>.
+/// Returns Config
+fn parse_arguments_simple(args: &Vec<String>) -> Config
+```
+
+Sie müssen nun in der Funktion:
+
+- den 1. String in einen char verwandeln
+- den 2. String der Config  Struktur zuweisen
+
+>Beachten Sie, das die Strings, die die Argumente repräsentieren in der Funktion
+>geliehen sind und somit jemand anderen gehören. Ihre Config Struktur benötigt
+>somit EIGENE Strings.
+
+In *main()* geben Sie die geparsten Parameter aus, sodass Sie bei Aufruf Ihres
+Programms "cargo run a b c" folgende Ausgabe erhalten:
+
+```text
+    Finished dev [unoptimized + debuginfo] target(s) in 0.27 secs
+     Running `target/debug/task1 a b c`
+args found: target/debug/task1
+args found: a
+args found: b
+args found: c
+Config { search: 'a', line: "b" }
+```
+
+#### Parsen mit Fehlerbehandlung
+
+1. Unter Umständen ruft ein Benutzer Ihr Programm ohne die benötigten Parameter
+   auf. Welche Fehlermeldung erhalten Sie bei dem Aufruf Ihres Programms ohne
+   Parameter und warum?
+
+1. Ein Programmabsturz wäre die falsche Antwort darauf. Besser ist beim
+   Auftreten von Eingabefehler ein entsprechender Hinweis, wie das Programm zu
+   verwenden ist. Implementieren Sie die Funktion
+
+```rust
+/// Parses relevant arguments, returning the filled Config in Result
+///
+///
+/// This function will parse the relevant arguments from the
+/// given <Strings>.
+/// Returns Config or Error Message in Result
+fn parse_arguments(args: &Vec<String>) -> Result<Config, xx >
+```
+
+Implementieren Sie die folgende Fehlerbehandlung:
+
+- Werden vom Benutzer zuwenig übergeben, so gibt die Funktion den Fehlerstring
+  "not enough arguments" zurück. Werden vom Benutzer zu viele Parameter
+  übergeben, so wertet die Funktion nur die ersten beiden aus. In der API der
+  Funktion oben ist als Typ xx für den 'String' angedeutet und muss entsprechend
+  von Ihnen mit dem richtigen Typen versehen werden.
+
+- Tritt ein Fehler beim Wandeln des 1. Parameter in einen char auf, so geben Sie
+  den String "char mismatch" als Fehlerstring in Result zurück. Wird statt eines
+  chars als 1. Parameter ein String übergeben, so werten Sie nur den ersten
+  Buchstaben davon aus.
+
+Die main() Funktion kann keine Return Werte zurückliefern. Um aber der
+aufrufenden Shell den Abbruch des Programms mitteilen zu können steht die
+Funktion *[process::exit()]* aus der Standardbibliothek zu Verfügung. Durch die
+Rückgabe von '1' signalisieren Sie der Shell, dass das Programm abgebrochen
+wurde.
+
+### Zeichen im String suchen
+
+In Ihrer vorherigen Homework haben Sie bereits eine ähnliche Funktionalität
+implementiert, die Sie nun in der *run()* Funktion übernehmen können.
+
+### Ablauf des Programms
+
+Zur Abgabe des Programms soll die  *main()* Funktion nur:
+
+- *parse_arguments()* und
+- *run()*
+
+benutzen. In diesen beiden Funktionen darf kein *unwrap()* mehr verwendet
+werden.
+
+Da die Tests jedoch auch die Funktion *parse_arguments_simple()* benutzt, darf
+diese nicht auskommentiert werden.
+
+#### Dead Code
+
+Um die Compiler Warnungen vor nicht benutzen Funktionen auszuschalten, fügen Sie
+direkt in der Zeile vor der Funktion folgende Anweisung hinzu
+
+```Rust
+#[allow(dead_code)]
+fn parse_arguments_simple(args: &Vec<String>) -> Config {
+...
+```
+
+## Restructuring
+
+Bisher ist alles in unserm `src/main.rs` Modul, wodurch dieses im Laufe der Zeit
+immer unübersichtlicher werden würde. Ziel ist es nun, das meiste aus der
+`main.rs` auszulagern, sodass nur noch die *main()* Funktion in `main.rs` steht.
+
+Ausgelagert wird der Code in eine Bibliothek, genauer gesagt in die Datei
+`src/lib.rs`. Um den Code aus `lib.rs` in `main.rs` verwenden zu können, müssen
+Sie ihre derzeitige 'Create' mit den entsprechenden 'extern' und 'use'
+Anweisungen in `main.rs`, erreichbar machen. Ergänzen Sie dazu in der
+`src/main.rs`:
+
+```Rust
+extern crate task2;
+use task2::Config;
+```
+
+Alle *use* Anweisungen stehen in der `main.rs`. Es müssen keine weiteren *use*
+Anweisungen in der lib.rs stehen
+
+### Parsen der Config als Methode
+
+Die *parse_arguments()* Methode steht noch in keinem Zusammenhang mit der
+Struktur, die die Methode mit Daten füllt.
+
+Schreiben Sie einen Konstruktor *new()* für die Datenstruktur *Config* und
+ersetzten Sie damit die *parse_arguments()* Funktion. Verwenden Sie nun Config
+geeignet in Ihrer *main()* Funktion.
+
+### Tests
+
+Die Test sind ausgelagert in die Datei `tests/task2.rs`. Der Aufruf von cargo
+test sucht nach Unit Tests in der `src/main.rs` und im Verzeichnis `tests/`. Die
+Tests in `tests/task2.rs` funktionieren erst, wenn eine `src/lib.rs` existiert
+(siehe Aufgabenstellung [Restructuring](#restructuring) oben).
+
+### Dokumentation
+
+Dokumentieren Sie die Funktionen in Ihrer `lib.rs`, sodass **cargo doc** eine
+aussagekräftige Dokumentation erstellt.
+
+Da Sie im `src/`Verzeichnis eine `main.rs` und eine `lib.rs` vorliegen haben,
+beschwert sich **cargo doc**, dass es nicht weiss wie es die Dokumentation
+erstellen soll:
+
+```text
+error: cannot document a package where a library and a binary have the same name. Consider renaming one or marking the target as `doc = false`
+```
+
+Damit **cargo doc** Ihre Dokumentation für die Funktionen in `lib.rs` erstellt,
+benötigen Sie folgende Erweiterung in Ihrer `Cargo.toml` Datei.
+
+```text
+[[bin]]
+doc = false
+name = "task2"
+```
+
+Damit weiß cargo, dass es die Dokumentation aus `lib.rs` erstellen soll und
+nicht aus `main.rs`.
+
+[args]: https://doc.rust-lang.org/std/env/fn.args.html
+[std::env]:https://doc.rust-lang.org/std/env/index.html
+[Arc]: https://doc.rust-lang.org/std/env/struct.Args.html
+[collect]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.collect
+[process::exit()]: https://doc.rust-lang.org/std/process/fn.exit.html

hw2/task2/src/lib.rs

@@ -0,0 +1,86 @@
+/// a struct to hold all of our configuration
+#[derive(Debug, PartialEq)]
+pub struct Config {
+    pub search: char,
+    pub line: String,
+}
+
+pub fn run(conf: &Config) -> i32 {
+    let mut count = 0;
+    for c in conf.line.chars() {
+        if c == conf.search {
+            count = count + 1;
+        }
+    }
+    count
+}
+
+/// Parses relevant arguments, returning the filled Config in Result
+///
+///
+/// This function will parse the relevant arguments from the
+/// given <Strings>.
+/// Returns Config or Error Message in Result
+#[allow(dead_code)]
+fn parse_arguments(args: &Vec<String>) -> Result<Config, String> {
+
+    if args.len() < 3 {
+        return Err("not ennugh parameters".to_string());
+    }
+
+    match args[1].chars().nth(0) {
+        Some(value) => {
+            Ok(Config {
+                search: value,
+                line: args[2].clone(),
+            })
+        }
+        None => Err("char mismatch".to_string()),
+    }
+}
+
+/// Parses relevant arguments, returning the filled Config
+///
+///
+/// This function will parse the relevant arguments from the
+/// given <Strings>.
+/// Returns Config
+#[allow(dead_code)]
+fn parse_arguments_simple(args: &Vec<String>) -> Config {
+    Config {
+        search: args[1].chars().nth(0).unwrap(),
+        line: args[2].clone(),
+    }
+}
+
+/// Prints elements of Vec
+///
+///
+/// This function will print all elements of Vec with "args found: <elem>" in
+/// each line
+///
+/// Returns nothing
+#[allow(dead_code)]
+fn print_arguments(args: &Vec<String>) {
+    for s in args {
+        println!("args found: {}", s);
+    }
+}
+
+impl Config {
+    pub fn new(args: &Vec<String>) -> Result<Config, &str> {
+        if args.len() < 3 {
+            return Err("not enough arguments");
+        }
+
+        match args[1].chars().nth(0) {
+            Some(value) => {
+                Ok(Config {
+                    search: value,
+                    line: args[2].clone(),
+                })
+            }
+            None => Err("char mismatch"),
+        }
+    }
+}

hw2/task2/src/main.rs

@@ -0,0 +1,28 @@
+use std::env;
+use std::process;
+use task2::Config;
+extern crate task2;
+
+fn main() {
+    let args = env::args().collect();
+
+    let res = Config::new(&args);
+    match res {
+        Ok(conf) => {
+            println!(
+                "You asked me to count all '{}' in '{}'",
+                conf.search,
+                conf.line
+            );
+            let occ = task2::run(&conf);
+            println!("Found {} '{}' in '{}'", occ, conf.search, conf.line);
+        }
+        Err(message) => {
+            println!("{}", message);
+            process::exit(1)
+        }
+    }
+
+
+
+}

hw2/task2/tests/output.bats

@@ -0,0 +1,41 @@
+#!/usr/bin/env bats
+
+
+@test "task2: Check that we have a debug output" {
+    run stat "$BATS_TEST_DIRNAME/../target/debug/task2"
+    [ "$status" -eq 0 ]
+}
+
+@test "task2: Output Long String: The quick ...." {
+    run "$BATS_TEST_DIRNAME/../target/debug/task2" 'q' '♥ The quick brown fox jumps over the lazy dog. ♥'
+    [[ "${lines[0]}" =~ "You asked me to count all 'q' in '♥ The quick brown fox jumps over the lazy dog. ♥'" ]]
+    [[ "${lines[1]}" =~ "Found 1 'q' in '♥ The quick brown fox jumps over the lazy dog. ♥'" ]]
+}
+
+@test "task2: Output Short String: ababab " {
+   run "$BATS_TEST_DIRNAME/../target/debug/task2" 'a' 'ababab'
+   [[ "${lines[0]}" =~ "You asked me to count all 'a' in 'ababab'" ]]
+   [[ "${lines[1]}" =~ "Found 3 'a' in 'ababab'" ]]
+}
+
+@test "task2: Output Error 1" {
+   run "$BATS_TEST_DIRNAME/../target/debug/task2"
+   [[ "${lines[0]}" =~ "not enough arguments" ]]
+}
+
+@test "task2: Output Error 2" {
+   run "$BATS_TEST_DIRNAME/../target/debug/task2"
+   [[ "${lines[0]}" =~ "not enough arguments" ]]
+}
+
+# wc output with white spaces is trimmed by xargs
+@test "task2: Output must be exact 2 line long" {
+    run bash -c "'$BATS_TEST_DIRNAME/../target/debug/task2' 'a' 'b' 'c' | wc -l | xargs"
+    [ "$output" = "2" ]
+}
+
+# wc output with white spaces is trimmed by xargs
+@test "task2: Output must be exact 1 line long" {
+    run bash -c "'$BATS_TEST_DIRNAME/../target/debug/task2' 'a'  | wc -l | xargs"
+    [ "$output" = "1" ]
+}

hw2/task2/tests/task2.rs

@@ -0,0 +1,95 @@
+extern crate task2;
+use task2::Config;
+
+
+#[test]
+fn test_parse_config_1() {
+    let a = vec![
+        "Not interested".to_string(),
+        "e".to_string(),
+        "Numero Due".to_string(),
+    ];
+    let c = Config {
+        search: 'e',
+        line: "Numero Due".to_string(),
+    };
+    assert_eq!(Config::new(&a), Ok(c));
+}
+
+#[test]
+#[should_panic]
+fn test_parse_config_2() {
+    let a = vec![
+        "Not interested".to_string(),
+        "x".to_string(),
+        "Numero Due".to_string(),
+    ];
+    let c = Config {
+        search: 'e',
+        line: "Numero Due".to_string(),
+    };
+    assert_eq!(Config::new(&a), Ok(c));
+}
+
+#[test]
+fn test_parse_config_3() {
+    let a = vec![
+        "Not interested".to_string(),
+        "0".to_string(),
+        "0".to_string(),
+    ];
+    let c = Config {
+        search: '0',
+        line: "0".to_string(),
+    };
+    assert_eq!(Config::new(&a), Ok(c));
+}
+
+#[test]
+fn test_parse_config_err_1() {
+    let a = vec!["Not interested".to_string(), "e".to_string()];
+    assert_eq!(Config::new(&a), Err("not enough arguments"));
+}
+
+#[test]
+fn test_parse_config_err_2() {
+    let a = vec!["Not interested".to_string()];
+    assert_eq!(Config::new(&a), Err("not enough arguments"));
+}
+
+#[test]
+fn test_run_1() {
+    let c = Config {
+        search: 'e',
+        line: "Numero Due".to_string(),
+    };
+    assert_eq!(task2::run(&c), 2);
+}
+
+#[test]
+fn test_run_2() {
+    let c = Config {
+        search: '♥',
+        line: "♥ The quick brown fox jumps over the lazy dog. ♥".to_string(),
+    };
+    assert_eq!(task2::run(&c), 2);
+}
+
+#[test]
+#[should_panic]
+fn test_run_3() {
+    let c = Config {
+        search: 'q',
+        line: "♥ The quick brown fox jumps over the lazy dog. ♥".to_string(),
+    };
+    assert_eq!(task2::run(&c), 2);
+}
+
+#[test]
+fn test_run_4() {
+    let c = Config {
+        search: '!',
+        line: "♥ The quick brown fox jumps over the lazy dog. ♥".to_string(),
+    };
+    assert_eq!(task2::run(&c), 0);
+}

hw2/task3/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "task3"
+version = "0.1.0"
+authors = ["Lorenz Bung <lorenz.bung@googlemail.com>"]
+
+[dependencies]

hw2/task3/README.md

@@ -0,0 +1,24 @@
+# Homework hw2 task3
+
+## prepare your task
+
+Run the cargo command to prepare your task3/ directory as a library
+
+## task
+
+Compute Pascal's triangle up to a given number of rows. Create the new type
+*PascalsTriangle* and implement the methods *new()* and *rows()*. See the
+`tests/task3.rs` for more informationen about parameters and returns of the
+methods. Do not use any crates.
+
+In Pascal's Triangle each number is computed by adding the numbers to the right
+and left of the current position in the previous row.
+
+```plain
+    1
+   1 1
+  1 2 1
+ 1 3 3 1
+1 4 6 4 1
+# ... etc
+```

hw2/task3/src/lib.rs

@@ -0,0 +1,45 @@
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+}
+
+pub struct PascalsTriangle {
+    height: u32,
+}
+
+impl PascalsTriangle {
+    pub fn new(i: u32) -> Self {
+        PascalsTriangle { height: i }
+    }
+    pub fn rows(&self) -> Vec<Vec<u32>> {
+        let rows = self.height as usize;
+        let mut matrix = Vec::with_capacity(rows);
+
+        for line in 0..rows {
+            let current = line as usize;
+            matrix.push(Vec::with_capacity(current + 1));
+            matrix[current].push(1);
+
+            if current > 1 {
+                let previous = current - 1;
+                for index in 1..current {
+                    let add = matrix[previous][index - 1] + matrix[previous][index];
+                    matrix[current].push(add);
+                }
+            }
+
+            if current > 0 {
+                matrix[current].push(1);
+            }
+
+        }
+
+        println!("{:?}", matrix);
+
+        matrix
+    }
+}

hw2/task3/src/main.rs

@@ -0,0 +1,7 @@
+extern crate task3;
+use task3::PascalsTriangle;
+
+fn main() {
+    let p = PascalsTriangle::new(10);
+    p.rows();
+}

hw2/task3/tests/task3.rs

@@ -0,0 +1,39 @@
+extern crate task3;
+
+use task3::*;
+
+#[test]
+fn no_rows() {
+    let pt = PascalsTriangle::new(0);
+    let expected: Vec<Vec<u32>> = Vec::new();
+    assert_eq!(expected, pt.rows());
+}
+
+
+#[test]
+fn one_row() {
+    let pt = PascalsTriangle::new(1);
+    let expected: Vec<Vec<u32>> = vec![vec![1]];
+    assert_eq!(expected, pt.rows());
+}
+
+#[test]
+fn two_rows() {
+    let pt = PascalsTriangle::new(2);
+    let expected: Vec<Vec<u32>> = vec![vec![1], vec![1, 1]];
+    assert_eq!(expected, pt.rows());
+}
+
+#[test]
+fn three_rows() {
+    let pt = PascalsTriangle::new(3);
+    let expected: Vec<Vec<u32>> = vec![vec![1], vec![1, 1], vec![1, 2, 1]];
+    assert_eq!(expected, pt.rows());
+}
+
+#[test]
+fn last_of_four_rows() {
+    let pt = PascalsTriangle::new(4);
+    let expected: Vec<u32> = vec![1, 3, 3, 1];
+    assert_eq!(expected, pt.rows().pop().unwrap());
+}

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 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/ANSWERS.md

@@ -0,0 +1,21 @@
+# Simulation 1 - Antworten
+
+1. Das letzte Segment liegt auf der dezimalen (virtuellen) Adresse 929. Damit dieses Segment in den Adressraum passt, muss dieser mindestens ein Limit von **930** haben.
+
+2. Der physikalische Adressraum ist 16kB groß und das Limit beträgt 100. 16384 - 100 = 16284
+
+3. Bei einer Vergrößerung des **Adressraums** (z.B. `-a 2k`) nimmt die Zahl der Segmentation-Fehler zu, da das Programm die Adressen aus einer **größeren Spanne** auswählt, das **Limit** der validen Adressen sich jedoch nicht ändert. Vergrößern wir jedoch die Größe des **physikalischen Speichers**, ändert sich nichts am Ergebnis - die Größe des verfügbaren Speichers hat nämlich *keinen Einfluss* darauf, aus welcher **Reichweite** das Programm Adressen auswählt bzw. bis zu welchem Limit Adressen **valide** sind.
+
+4.
+VA | Seg. Vio.?
+---|---
+0|no
+1|yes
+2|no
+3|no
+4|yes
+5|yes
+6|yes
+7|no
+8|yes
+9|no

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/ANSWERS.md

@@ -0,0 +1,82 @@
+## Warmup
+
+| VA Number | Virtual Adress     | Physical Adress     | Valid |
+| --------- | :----------------- | ------------------- | ----- |
+| VA  0     | 0x11  --> 0010001  | 000010001 --> 0x011 | YES   |
+| VA  1     | 0x6c  --> 1101100  | 111101100 --> 0x1ec | YES   |
+| VA  2     | 0x61  --> 1100001  | 111100001 --> 0x1e1 | NO    |
+| VA  3     | 0x20  --> 0100000  | 00100000 --> 0x020  | NO    |
+| VA  4     | 0x3f   --> 0111111 | 00111111 --> 0x03f  | NO    |
+
+
+
+```
+ --------------- 0x00000000
+ |  Segment 0  |
+ |-------------| 0x00000014
+ |             |
+ |             |
+ |             |
+ |             |
+ |-------------| 0x000001ec
+ |  Segment 1  |
+ |-------------| 0x00000200
+```
+
+
+
+## Antworten
+
+1.  Die höchste erlaubte Adresse in Segment 0 ist 0x00000013. Die niedrigste valide Addresse des Segments 1 ist 0x000001ec. Die niedrigste illegale Adresse ist 0x0000014 und die höchste illegale Adresse ist 0x000001eb im gesamten Adressraum. Um zu testen ob das stimmt kann mann alle validen  virtuellen Adressen der Segmente UND jeweils (mindestens) eine über dem Limit mit `-A` angeben.
+
+     `-A 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,`
+
+     `106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127`
+
+
+2.   Der Aufruf muss wie folgt aussehen:
+
+    > ./segmentation.py -a 16 -p 128 -A 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 **--b0 0 --l0 2 --b1 16 --l1 2** -c
+
+    Die Flags `-l0` und `-l1` setzten jeweils das Limit für das Segment auf 2:
+
+    ​	Segment 0 nimmt also die virtuellen Adressen 0 und 1 an und
+
+    ​	Segment 1 nimmt die Adressen 14 und 15 an
+
+3.   Man sollte das Limit `-l` so wählen, dass es 90% der Adressen des Adressraums `-a` abdeckt. Dann werden die restlichen 10% der virtuellen Adressen über das gesetzte Limit gehen und einen Segmentation Fault auslösen.
+
+4.  Man setzt die Limits der Segmente mit `-l 0` auf 0, dann ist keine virtuelle Adresse valide. 
+
+5.  Im folgenden wird VA für virtuelle Adresse und PA für physikalische Adresse benutzt.
+
+    `Segment 0: 0x0000 bis 0x0040`
+
+    `Segment 1: 0x0380 bis 0x0400`
+
+    Höchste VA **0x16C** -> (mappt auf) höchste PA **0x400**
+
+    1024 - 364 = 660 (Segment 1 Offset)
+
+    | VA Nr. | VA HEX     | VA BIN          | Physical Address HEX   | PA DEC |
+    | ------ | ---------- | --------------- | ---------------------- | :----: |
+    | 0      | 0x0000005c | 00\|1011100     | Segmentation Violation |   -    |
+    | 1      | 0x00000011 | 00\|0010001     | **0x00000011**         |   17   |
+    | 2      | 0x00000043 | 00\|1000011     | Segmentation Violation |   -    |
+    | 3      | 0x00000021 | 00\|0100001     | **0x00000021**         |   33   |
+    | 4      | 0x0000006c | 00\|1101100     | Segmentation Violation |   -    |
+    | 5      | 0x0000007a | 00\|1111010     | Segmentation Violation |   -    |
+    | 6      | 0x00000050 | 00\|1010000     | Segmentation Violation |   -    |
+    | 7      | 0x00000037 | 00\|0110111     | **0x00000037**         |   55   |
+    | 8      | 0x000000ff | **01**\|1111111 | **0x00000393**         |  915   |
+    | 9      | 0x000000e9 | **01**\|1101001 | Segmentation Violation |   -    |
+    | 10     | 0x00000001 | 00\|0000001     | **0x00000001**         |   1    |
+    | 11     | 0x0000014c | **10**\|1001100 | **0x000003e0**         |  992   |
+    | 12     | 0x000000b4 | **01**\|0110100 | Segmentation Violation |   -    |
+    | 13     | 0x000000cf | **01**\|1001111 | Segmentation Violation |   -    |
+    | 14     | 0x0000012b | **10**\|0101011 | **0x000003bf**         |  959   |
+    | 15     | 0x00000084 | **01**\|0000100 | Segmentation Violation |   -    |
+
+    Zuerst überprüft man in welchem Segment die VA liegt, indem man auf das höchste bit der binären VA schaut. Wenn sie im Segment 0 liegt dann ist VA => PA und man kann prüfen, ob die Adresse im oben berechneten physikalischen Adressbereich von Segment 0 liegt. Wenn nicht => SEG FAULT.
+
+    Wenn die VA in Segment 1 liegt, dann muss man vorher den berechneten Offset vonn dezimal 660 oder hexadezimal 0x258 aufaddieren. Dann hat man die PA und kann dann schauen ob sie im physikalischen Adressbereich von Segment 1 liegt. Wenn nicht => SEG FAULT.

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/ANSWERS.md

@@ -0,0 +1,111 @@
+# Warmup
+
+Die Entwicklung des Speichers nach ausführen von `./malloc.py -n 10 -H 0 -p BEST -s` 
+
+```
+ --------------- 1000
+ |             |
+ |             |
+ |-------------| 1100
+```
+
+```
+ --------------- 1000
+ |   alloc'd   |
+ |-------------| 1003
+ |             |
+ |             |
+ |    FREE     |
+ |             |
+ |             |
+ |-------------| 1100
+```
+
+```
+ --------------- 1000
+ |    FREE     |
+ |-------------| 1003
+ |             |
+ |             |
+ |    FREE     |
+ |             |
+ |             |
+ |-------------| 1100
+```
+
+```
+ --------------- 1000
+ |    FREE     |
+ |-------------| 1003
+ |   alloc'd   |
+ |-------------| 1008
+ |             |
+ |    FREE     |
+ |             |
+ |-------------| 1100
+```
+```
+ --------------- 1000
+ |    FREE     |
+ |-------------| 1003
+ |    FREE     |
+ |-------------| 1008
+ |             |
+ |    FREE     |
+ |             |
+ |-------------| 1100
+```
+```
+ --------------- 1000
+ |    FREE     |
+ |-------------| 1003
+ |    FREE     |
+ |-------------| 1008
+ |   alloc'd   |
+ |-------------| 1016
+ |    FREE     |
+ |-------------| 1100
+```
+```
+ --------------- 1000
+ |    FREE     |
+ |-------------| 1002
+ |   alloc'd   |
+ |-------------| 1003
+ |    FREE     |
+ |-------------| 1008
+ |    FREE     |
+ |-------------| 1016
+ |    FREE     |
+ |-------------| 1100
+```
+```
+ --------------- 1000
+ |    FREE     |
+ |-------------| 1002
+ |   alloc'd   |
+ |-------------| 1003
+ |    FREE     |
+ |-------------| 1008
+ |   alloc'd   |
+ |-------------| 1015
+ |    FREE     |
+ |-------------| 1016
+ |    FREE     |
+ |-------------| 1100
+```
+
+Wie man sieht hat die Fragmentierung des Speichers bzw. der Free-Liste zugenommen.
+
+# Antworten
+
+1. Wenn zwei mal ein gleich großes Speicherstück alloziiert wird, dann wird nicht das wieder freigewordene Fragment genutzt, sondern ein neues reserviert. Auch Alloziierungen von kleineren Stücken bekommen keine Teile von wieder freigegebenem Platz. Also ensteht im allgemeinen eine höhere Fragmentierung als mit **BEST**.
+2. Die Struktur der Free-Liste ändert sich nicht, aber es werden weniger Elemente (Speicherblöcke) gesucht, bevor die Adresse zurückgeliefert wird. Je größer die Free-Liste, desto länger dauert es, diese zu durchsuchen. Das Flag **FIRST** verkürzt also die Suchzeit und somit auch die insgesamte alloc-Zeit.
+3. Die verschiedenen Sortiermechanismen:
+   - **ADDRSORT** sortiert die Liste mit dem freien Speicher nach der höhe der Adresse. Es verändert sich nichts zu vorher mit anderen Policies.
+   - Bei **SIZESORT+** sind die kleinsten *Stücke* vorne in der Liste. Bei **BEST** ist dann oft der Verschnitt, also 1-Byte-Blöcke am Anfang. 
+   - Bei **SIZESORT-** wird die Speicherliste absteigend nach der Größe der Blöcke sortiert. Diese Sortierung ist vorteilhaft für die Policy **FIRST**, da große Blöcke direkt am Anfang gefunden werden die sehr häufig für den angeforderten Speicher ausreichen. 
+4. Bei größeren Speicheranforderungen schlägt malloc fehl, mit dem Rückgabewert `-1` und die Free-Liste ist sehr groß. Wenn man nun die Verschmelzung von freiem Speicher mit `-C`  aktiviert, dann schlägt keine Allozierung mehr fehl und die Liste des freien Speichers ist kleiner. Die Sortierung der Liste spielt keine Rolle, da keine Fragmente über andere Adressen hinweg miteinander verschmolzen werden können.
+5. Wenn ein Faktor von über 50% erlaubt wird, dann bleibt die Liste klein, da der Speicher nicht wieder freigegeben wird. Bei Werten bis zu 100% kommt es definitiv zu einem Fehler bei der Alloziierung, da nicht genug freier Speicher vorhanden ist. Bei Werten, die gegen 0 gehen wird nach jedem **alloc** ein **free** aufgerufen und es ist immer wieder freier Speicher vorhanden.
+6. ​In dem man bei jedem **alloc** ein Byte mehr Speicher als davor anfordert, muss immer ein neuer "Block" angefangen werden. Dabei hilft die Policy BEST auch nichts mehr, da die neuen Allozierungen nie in die wieder frei gewordene kleinere Speicherstücke passt.
+

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/ANSWERS.md

@@ -0,0 +1,14 @@
+# Simulation 4 - Antworten
+
+1.1. Die Tabellengröße kann mit folgender Gleichung beschrieben werden: `T = a/P` mit `T` = Tabellengröße, `a` = Adressraumgröße und `P` = Seitengröße.
+
+1.2. Aus obiger Formel lässt sich schließen: Mit wachsendem Adressraum sollte die Tabellengröße mit gleichem Faktor wachsen, mit wachsender Seitengröße sollte die Tabellengröße mit gleichem Faktor sinken.
+
+1.3. Bei einem Kontextwechsel muss bei großer Seitengröße mehr geladen werden. Das benötigt Zeit.
+
+2. Je größer der Anteil der zum Adressraum zugeordneten Seiten wird, desto weniger Segmentation-Fehler treten auf.
+
+3. Der Parameter `-P 1m -a 256m -p 512m -v -s 3` ist unrealistisch, da eine Seitengröße von 1MB Größe viel zu groß ist, um praktikabel zu sein.
+
+4. Wenn der Adressraum größer als der physikalische Speicher ist, gibt das Programm eine Fehlermeldung aus.
+Weitere Fehler können manuell provoziert werden, wenn zum Beispiel eine negative Seitengröße (`math domain error`) oder die Seitengröße mit 0 angegeben werden (`float division by 0`). Auch beim angeben eines leeren Adressraums tritt ein Fehler auf (`must specify a non-zero address-space size`), genauso auch bei der physikalischen Speichergröße. Außerdem bekommt man einen Index-Fehler (`array index out of bounds`), wenn man eine sehr große (z.B. `2^31`) Seitengröße verwendet.

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 ''
+
+
+
+
+
+
+

hw4/README.md

@@ -0,0 +1,28 @@
+# hw4
+
+To fulfill **hw4** you have to solve:
+
+- task1
+- simu1
+- simu2
+- simu3
+
+Optional are (bonus +2P):
+
+- task2 (Homework in OSTEP Chapter 19 in **Rust**)
+
+## Pull-Reuest
+
+Please merge any accepted reviews into your branch. If you are ready with the homework, all tests run, please create a pull request named **hw4**.
+
+## Credits for hw4
+
+| Task     | max. Credits | Comment |
+| -------- | ------------ | ------- |
+| task1    | 2            |         |
+| simu1    | 0.5          |         |
+| simu2    | 1            |         |
+| simu3    | 0.5          |         |
+| task2    | +2           |         |
+| Deadline | +1           |         |
+| =        | 7            |         |

hw4/simu1/ANSWERS.md

@@ -0,0 +1,39 @@
+# hw4 - Simulation 1 - Lösungen
+
+### Warmup
+
+`0x611c` =>
+
+`0110 0001 0001 1100` =>
+
+| Valid | PDE | PTE | Offset |
+|-------|-----|-----|--------|
+|0      |11000|01000|11100   |
+| False | 24  | 8   | 28     |
+
+PDE at index 24:
+
+> page 108: 83 [...] e9 **a1** e8 [...] ff
+
+
+
+`0xa1` => `1010 0001` => `1 | 0100001` => Valid | 33
+
+PTE at index 8 in page 33 (found in PDE):
+
+> page 33: 7f [...] 7f **b5** 7f [...] 7f
+
+
+`0xb5` => `1011 0101` => `1 | 0110101` => Valid | 53
+
+Final Value is in page `0xb5` (53) with offset 28 => 0x08 (8).
+
+
+
+### Aufgaben
+
+1. Für eine zweistufige Seitentabelle benötigt man ein Register, für eine dreistufige Seitentabelle bräuchte man ein zweites PDBR.
+
+2. Da es sich bei dieser Simulation um eine zweistufige Seitentabelle handelt, gibt es eine Referenz für den PDE, eine für den PTE und schlussendlich noch eine dritte Referenz, in der das Endergebnis steht.
+
+3. Da der Cache nicht im Voraus weiß, auf welche Adresse nach der Übersetzung des PDE bzw. PTE zugegriffen wird, müssen danach erst wieder Daten in den Cache geladen werden. Dies führt zu einer Reihe von Cache Misses.

hw4/simu1/QUESTIONS.md

@@ -0,0 +1,12 @@
+# Questions 20-paging-multilevel-translate
+
+This fun little homework tests if you understand how a multi-level page table works. And yes, there is some debate over the use of the term “fun” in the previous sentence. The program is called, perhaps unsurprisingly: `paging-multilevel-translate.py`; see the README for details.
+Questions
+
+## Questions
+
+1. With a linear page table, you need a single register to locate the page table, assuming that hardware does the lookup upon a TLB miss. How many registers do you need to locate a two-level page table? A three-level table?
+
+1. Use the simulator to perform translations given random seeds 0, 1, and 2, and check your answers using the -c flag. How many memory references are needed to perform each lookup?
+
+1. Given your understanding of how cache memory works, how do you think memory references to the page table will behave in the cache? Will they lead to lots of cache hits (and thus fast accesses?) Or lots of misses (and thus slow accesses)? Explain your answer in detail!

hw4/simu1/README-paging-multilevel-translate.md

@@ -0,0 +1,80 @@
+# README Paging: Multilevel Translate
+
+This fun little homework tests if you understand how a multi-level page table
+works. And yes, there is some debate over the use of the term fun in the
+previous sentence. The program is called: `paging-multilevel-translate.py`
+
+Some basic assumptions:
+
+- The page size is an unrealistically-small 32 bytes
+- The virtual address space for the process in question (assume there is only
+  one) is 1024 pages, or 32 KB
+- physical memory consists of 128 pages
+
+Thus, a virtual address needs 15 bits (5 for the offset, 10 for the VPN). A
+physical address requires 12 bits (5 offset, 7 for the PFN).
+
+The system assumes a multi-level page table. Thus, the upper five bits of a
+virtual address are used to index into a page directory; the page directory
+entry (PDE), if valid, points to a page of the page table. Each page table page
+holds 32 page-table entries (PTEs). Each PTE, if valid, holds the desired
+translation (physical frame number, or PFN) of the virtual page in question.
+
+The format of a PTE is thus:
+
+```text
+  VALID | PFN6 ... PFN0
+```
+
+and is thus 8 bits or 1 byte.
+
+The format of a PDE is essentially identical:
+
+```text
+  VALID | PT6 ... PT0
+```
+
+You are given two pieces of information to begin with.
+
+First, you are given the value of the page directory base register (PDBR), which
+tells you which page the page directory is located upon.
+
+Second, you are given a complete dump of each page of memory. A page dump looks
+like this:
+
+```text
+    page 0: 08 00 01 15 11 1d 1d 1c 01 17 15 14 16 1b 13 0b ...
+    page 1: 19 05 1e 13 02 16 1e 0c 15 09 06 16 00 19 10 03 ...
+    page 2: 1d 07 11 1b 12 05 07 1e 09 1a 18 17 16 18 1a 01 ...
+    ...
+```
+
+which shows the 32 bytes found on pages 0, 1, 2, and so forth. The first byte
+(0th byte) on page 0 has the value 0x08, the second is 0x00, the third 0x01, and
+so forth.
+
+You are then given a list of virtual addresses to translate.
+
+Use the PDBR to find the relevant page table entries for this virtual page. Then
+find if it is valid. If so, use the translation to form a final physical
+address. Using this address, you can find the VALUE that the memory reference is
+looking for.
+
+Of course, the virtual address may not be valid and thus generate a fault.
+
+Some useful options:
+
+- Change the seed to get different problems, as always:
+  ```text
+    -s SEED, --seed=SEED       the random seed
+  ```
+
+- Change the number of virtual addresses generated to do more translations for a given memory dump.
+  ```text
+    -n NUM, --addresses=NUM    number of virtual addresses to generate
+  ```
+
+- Use -c (or --solve) to show the solutions.
+  ```text
+    -c, --solve                compute answers for me
+  ```

hw4/simu1/paging-multilevel-translate.py

@@ -0,0 +1,265 @@
+#! /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
+
+def roundup(size):
+    value = 1.0
+    while value < size:
+        value = value * 2.0
+    return value
+
+    
+class OS:
+    def __init__(self):
+        # 4k phys memory (128 pages)
+        self.pageSize  = 32
+        self.physPages = 128
+        self.physMem   = self.pageSize * self.physPages
+        self.vaPages   = 1024
+        self.vaSize    = self.pageSize * self.vaPages
+        self.pteSize   = 1
+        self.pageBits  = 5 # log of page size
+
+        # os tracks
+        self.usedPages      = []
+        self.usedPagesCount = 0
+        self.maxPageCount   = self.physMem / self.pageSize
+
+        # no pages used (yet)
+        for i in range(0, self.maxPageCount):
+            self.usedPages.append(0)
+
+        # set contents of memory to 0, too
+        self.memory = []
+        for i in range(0, self.physMem):
+            self.memory.append(0)
+
+        # associative array of pdbr's (indexed by PID)
+        self.pdbr = {}
+
+        # mask is 11111 00000 00000 --> 0111 1100 0000 0000 
+        self.PDE_MASK    = 0x7c00
+        self.PDE_SHIFT   = 10
+
+        # 00000 11111 00000 -> 000 0011 1110 0000
+        self.PTE_MASK    = 0x03e0
+        self.PTE_SHIFT   = 5
+
+        self.VPN_MASK    = self.PDE_MASK | self.PTE_MASK
+        self.VPN_SHIFT   = self.PTE_SHIFT
+
+        # grabs the last five bits of a virtual address
+        self.OFFSET_MASK = 0x1f
+
+    def findFree(self):
+        assert(self.usedPagesCount < self.maxPageCount)
+        look = int(random.random() * self.maxPageCount)
+        while self.usedPages[look] == 1:
+            look = int(random.random() * self.maxPageCount)
+        self.usedPagesCount = self.usedPagesCount + 1
+        self.usedPages[look] = 1
+        return look
+
+    def initPageDir(self, whichPage):
+        whichByte = whichPage << self.pageBits
+        for i in range(whichByte, whichByte + self.pageSize):
+            self.memory[i] = 0x7f
+
+    def initPageTablePage(self, whichPage):
+        self.initPageDir(whichPage)
+
+    def getPageTableEntry(self, virtualAddr, ptePage, printStuff):
+        pteBits = (virtualAddr & self.PTE_MASK) >> self.PTE_SHIFT
+        pteAddr = (ptePage << self.pageBits) | pteBits
+        pte     = self.memory[pteAddr]
+        valid   = (pte & 0x80) >> 7
+        pfn     = (pte & 0x7f)
+        if printStuff == True:
+            print '    --> pte index:0x%x [decimal %d] pte contents:0x%x (valid %d, pfn 0x%02x [decimal %d])' % \
+                  (pteBits, pteBits, pte, valid, pfn, pfn)
+        return (valid, pfn, pteAddr)
+
+    def getPageDirEntry(self, pid, virtualAddr, printStuff):
+        pageDir = self.pdbr[pid]
+        pdeBits = (virtualAddr & self.PDE_MASK) >> self.PDE_SHIFT
+        pdeAddr = (pageDir << self.pageBits) | pdeBits
+        pde     = self.memory[pdeAddr]
+        valid   = (pde & 0x80) >> 7
+        ptPtr   = (pde & 0x7f)
+        if printStuff == True:
+            print '  --> pde index:0x%x [decimal %d] pde contents:0x%x (valid %d, pfn 0x%02x [decimal %d])' % \
+                  (pdeBits, pdeBits, pde, valid, ptPtr, ptPtr)
+        return (valid, ptPtr, pdeAddr)
+
+    def setPageTableEntry(self, pteAddr, physicalPage):
+        self.memory[pteAddr] = 0x80 | physicalPage
+
+    def setPageDirEntry(self, pdeAddr, physicalPage):
+        self.memory[pdeAddr] = 0x80 | physicalPage
+        
+    def allocVirtualPage(self, pid, virtualPage, physicalPage):
+        # make it into a virtual address, as everything uses this (and not VPN)
+        virtualAddr = virtualPage << self.pageBits
+        (valid, ptPtr, pdeAddr) = self.getPageDirEntry(pid, virtualAddr, False)
+        if valid == 0:
+            # must allocate a page of the page table now, and have the PD point to it
+            assert(ptPtr == 127)
+            ptePage = self.findFree()
+            self.setPageDirEntry(pdeAddr, ptePage)
+            self.initPageTablePage(ptePage)
+        else:
+            # otherwise, just extract page number of page table page
+            ptePage = ptPtr
+        # now, look up page table entry too, and mark it valid and fill in translation
+        (valid, pfn, pteAddr) = self.getPageTableEntry(virtualAddr, ptePage, False)
+        assert(valid == 0)
+        assert(pfn == 127)
+        self.setPageTableEntry(pteAddr, physicalPage)
+
+    # -2 -> PTE fault, -1 means PDE fault
+    def translate(self, pid, virtualAddr):
+        (valid, ptPtr, pdeAddr) = self.getPageDirEntry(pid, virtualAddr, True)
+        if valid == 1:
+            ptePage = ptPtr
+            (valid, pfn, pteAddr) = self.getPageTableEntry(virtualAddr, ptePage, True)
+            if valid == 1:
+                offset = (virtualAddr & self.OFFSET_MASK)
+                paddr  = (pfn << self.pageBits) | offset
+		# print '     --> pfn: %02x  offset: %x' % (pfn, offset)
+                return paddr
+            else:
+                return -2
+        return -1
+
+    def fillPage(self, whichPage):
+        for j in range(0, self.pageSize):
+            self.memory[(whichPage * self.pageSize) + j] = int(random.random() * 31)
+
+    def procAlloc(self, pid, numPages):
+        # need a PDBR: find one somewhere in memory
+        pageDir = self.findFree()
+        # print '**ALLOCATE** page dir', pageDir
+        self.pdbr[pid] = pageDir
+        self.initPageDir(pageDir)
+
+        used = {}
+        for vp in range(0, self.vaPages):
+            used[vp] = 0
+        allocatedVPs = []
+        
+        for vp in range(0, numPages):
+            vp = int(random.random() * self.vaPages)
+            while used[vp] == 1:
+                vp = int(random.random() * self.vaPages)
+            assert(used[vp] == 0)
+            used[vp] = 1
+            allocatedVPs.append(vp)
+            pp = self.findFree()
+            # print '**ALLOCATE** page', pp
+            # print '  trying to map vp:%08x to pp:%08x' % (vp, pp)
+            self.allocVirtualPage(pid, vp, pp)
+            self.fillPage(pp)
+        return allocatedVPs
+
+    def dumpPage(self, whichPage):
+        i = whichPage
+        for j in range(0, self.pageSize):
+            print self.memory[(i * self.pageSize) + j],
+        print ''
+
+    def memoryDump(self):
+        for i in range(0, self.physMem / self.pageSize):
+            print 'page %3d:' %  i, 
+            for j in range(0, self.pageSize):
+                print '%02x' % self.memory[(i * self.pageSize) + j],
+            print ''
+
+    def getPDBR(self, pid):
+        return self.pdbr[pid]
+
+    def getValue(self, addr):
+        return self.memory[addr]
+
+# allocate some processes in memory
+# allocate some multi-level page tables in memory
+# make a bit of a mystery:
+# can examine PDBR (PFN of current proc's page directory)
+# can examine contents of any page
+# fill pages with values too
+# ask: when given
+#   LOAD VA, R1
+# what will final value will be loaded into R1?
+
+#
+# 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', '--allocated', default=64, help='number of virtual pages allocated',
+                  action='store', type='int', dest='allocated')
+parser.add_option('-n', '--addresses', default=10, help='number of virtual addresses to generate',
+                  action='store', type='int', dest='num')
+parser.add_option('-c', '--solve', help='compute answers for me', action='store_true', default=False, dest='solve')
+
+
+(options, args) = parser.parse_args()
+
+print 'ARG seed', options.seed
+print 'ARG allocated',  options.allocated
+print 'ARG num',  options.num
+print ""
+
+random.seed(options.seed)
+
+# do the work now
+os = OS()
+used = os.procAlloc(1, options.allocated)
+
+os.memoryDump()
+
+print '\nPDBR:', os.getPDBR(1), ' (decimal) [This means the page directory is held in this page]\n'
+
+for i in range(0, options.num):
+    if (random.random() * 100) > 50.0 or i >= len(used):
+        vaddr = int(random.random() * 1024 * 32)
+    else:
+        vaddr = (used[i] << 5) | int(random.random() * 32)
+    if options.solve == True:
+        print 'Virtual Address %04x:' % vaddr
+        r = os.translate(1, vaddr)
+        if r > -1:
+            print '      --> Translates to Physical Address 0x%03x --> Value: %02x' % (r, os.getValue(r))
+        elif r == -1:
+            print '      --> Fault (page directory entry not valid)'
+        else:
+            print '      --> Fault (page table entry not valid)'
+    else:
+        print 'Virtual Address %04x: Translates To What Physical Address (And Fetches what Value)? Or Fault?' % vaddr
+
+print ''
+
+exit(0)
+
+
+
+
+

hw4/simu2/ANSWERS.md

@@ -0,0 +1,31 @@
+
+# Simulation 2 - Antworten
+
+Diese Simulation wurde auf einem Laptop mit 8GB RAM, einer 8GB swapfile und 4 Prozessorkernen ausgeführt.
+
+
+1. Wenn man *mem* mit auch nur mit 1 MB Speicher aufruft, dann geht die CPU Auslastung eines Kerns auf 100%. Im Idle Zustand war die user-time bei ~1%. Bei nur einem laufenden mem-Programm betrug die user-time ~25%. Bei 3 laufenden Instanzen waren es ~80% und bei 4 ~99% user-time.
+
+   Das klingt absolut logisch, da der Prozessor des Systems 4 Kerne hat. Denn wenn auf jedem Kern ein mem-Programm läuft, dann hat das Bertriessystem keinen eigenen Kern und die prozentuale sys-time wird winzig.
+
+2. Direkt nach dem Ausführen von ./mem 1024 hat sich der freie Speicher um ~1.050.000 Byte verringert und die Spalte swpd hat sich nicht verändert, sondern blieb auf 0. Sobald wir das mem-Programm (mit Ctrl-C) beendet haben, ist der freie Speicher (free) fast wieder auf den Urprungswert gesprungen.
+
+   Es fehlten ~250 Byte. Der freie Speicher hat sich danach also verkleinert. Auf der Workstation wurde bereits bei 1024 Byte *geswapped* und der freie Speicher war nach dem Beenden des Programms größer.
+
+3. Bei ./mem 4000 gab es auf dem Rechner (mit 8GB RAM) absolut kein swap-in / swap-out. Es sei denn, der freie Speicher von den gesamten 8GB war kleiner als die ~4GB. Unter normaler Last war erst bei ./mem 7000 ein deutlicher swap-in und -out sichtbar.
+
+   Bei jedem der Werte war jedoch der erste *loop* immer langsamer. Durschnittlich war er oft ~50% langsamer. Im ersten Loop werden 6x durchschnittlich 244.000 Byte in den Swap geschrieben (swap-out). Das ergibt die ~1.700.000 bei (swpd). Es werden bei ./mem 7000 ~5.400.000 Bytes in den physikalischen Speicher ausgelagert und insgesamt ~1.700.000 in den Swap. Das sind zusammen ungefähr die angeforderten 7 GB.
+   
+   In den folgenden Loops fand kaum noch ein swap-out statt (durchschnittlich ~0 Byte), dafür aber Rückschrieb von Swap in den RAM (swap-in).
+
+4. Die CPU Auslastung durch das mem-Programm ist immens. Wenn man es auf dem Laptop ausführt, drehen direkt die Lüfter hoch. Doch wie zu erwarten und im Quellcode zu sehen, ist das C-Programm nicht *multi-threaded*. In einem beliebigen System Monitor (z.B. htop) sieht man, dass nur ein Kern ausgelastet ist.
+
+   Im ersten Loop entsprechen die Werte von **swap-out** ungefähr den den Werten von **block-out**, aber es finden auch **block-in**s im ähnlichen Werteberich statt.
+
+5. Bei 4000 Byte braucht der erste loop 1070 ms und alle restlichen 745ms
+
+   Da bereits beim Aufruf von ./mem 8192 ein Segmentation Fault auftritt, war es nicht möglich über die Grenze des physikalischen 8GB Speichers (8192 kByte) zu gehen. Der Rest dieser Aufgabe ist also nicht wirklich beantwortbar.
+
+   Bei ./mem 8191 muss allerdings auch schon massiv *geswapped* werden. Der erste Loop braucht 6 Sekunden und die folgenden mehr als 60 Sekunden. Die Bandbreite in Loop 0 war noch bei 1317 MB/s in Loop 1 schon 128 MB/s und in den folgenden Loops ~110 MB/s. Man merkt dass nun die Festplatte der *bottleneck* ist, da das Programm kaum noch CPU Leistung benötigt.
+
+6. Bei 14584 schlägt die Speicheralloziierung fehl.

hw4/simu2/Makefile

@@ -0,0 +1,6 @@
+
+all: mem
+
+mem: mem.c
+	gcc -o mem mem.c -Wall -O
+

hw4/simu2/QUESTIONS.md

@@ -0,0 +1,21 @@
+# Questions 21-Physical-Memory-Mechanisms
+
+This homework introduces you to a new tool, **vmstat**, and how it can be used to get a sense of what your computer is doing with regards to memory, CPU, and I/O usage (with a focus on memory and swapping).
+
+Read the associated README and examine the code in mem.c before proceeding to the exercises and questions below.
+
+## Questions
+
+1. First, open two separate terminal connections to the same machine, so that you can easily run something in one window and the other. Now, in one window, run `vmstat 1`, which shows statistics about machine usage every second. Read the man page, the associated README, and any other information you need so that you can understand its output. Leave this window running **vmstat** for the rest of the exercises below.
+
+   Now, we will run the program `mem.c` but with very little memory usage. This can be accomplished by typing `./mem 1` (which uses only 1 MB of memory). How do the CPU usage statistics change when running mem? Do the numbers in the user time column make sense? How does this change when running more than one instance of mem at once?
+
+2. Let’s now start looking at some of the memory statistics while running mem. We’ll focus on two columns: swpd (the amount of virtual memory used) and free (the amount of idle memory). Run `./mem 1024` (which allocates 1024 MB) and watch how these values change. Then kill the running program (by typing control-c) and watch again how the values change. What do you notice about the values? In particular, how does the free column change when the program exits? Does the amount of free memory increase by the expected amount when mem exits?
+
+3. We’ll next look at the swap columns (si and so), which indicate how much swapping is taking place to and from the disk. Of course, to activate these, you’ll need to run mem with large amounts of memory. First, examine how much free memory is on your Linux system (for example, by typing cat `/proc/meminfo`; type **man proc** for details on the */proc* file system and the types of information you can find there). One of the first entries in `/proc/meminfo` is the total amount of memory in your system. Let’s assume it’s something like 8 GB of memory; if so, start by running mem 4000 (about 4 GB) and watching the swap in/out columns. Do they ever give non-zero values? Then, try with 5000, 6000, etc. What happens to these values as the program enters the second loop (and beyond), as compared to the first loop? How much data (total) are swapped in and out during the second, third, and subsequent loops? (do the numbers make sense?)
+
+4. Do the same experiments as above, but now watch the other statistics (such as CPU utilization, and block I/O statistics). How do they change when mem is running?
+
+5. Now let’s examine performance. Pick an input for mem that comfortably fits in memory (say 4000 if the amount of memory on the system is 8 GB). How long does loop 0 take (and subsequent loops 1, 2, etc.)? Now pick a size comfortably beyond the size of memory (say 12000 again assuming 8 GB of memory). How long do the loops take here? How do the bandwidth numbers compare? How different is performance when constantly swapping versus fitting everything comfortably in memory? Can you make a graph, with the size of memory used by mem on the x-axis, and the bandwidth of accessing said memory on the y-axis? Finally, how does the performance of the first loop compare to that of subsequent loops, for both the case where everything fits in memory and where it doesn’t?
+
+6. Swap space isn’t infinite. You can use the tool **/sbin/swapon** with the -s flag to see how much swap space is available. What happens if you try to run mem with increasingly large values, beyond what seems to be available in swap? At what point does the memory allocation fail?

hw4/simu2/README-mem-vmstat.md

@@ -0,0 +1,92 @@
+# README
+
+In this homework, you'll be investigating swap performance with a simple
+program found in `mem.c. The program is really simple: it just allocates an
+array of integers of a certain size, and then proceeds to loop through it
+(repeatedly), incrementing each value in the array.
+
+Type "make" to build it (and look at the file Makefile for details about how
+the build works).
+
+Then, type "./mem" followed by a number to run it. The number is the size (in
+MB) of the array. Thus, to run with a small array (size 1 MB):
+
+```text
+prompt> ./mem 1
+```
+
+and to run with a larger array (size 1 GB):
+
+```text
+prompt> ./mem 1024
+```
+
+The program prints out the time it takes to go through each loop as well as
+the bandwidth (in MB/s). Bandwidth is particularly interesting to know as it
+gives you a sense of how fast the system you're using can move through data;
+on modern systems, this is likely in the GB/s range.
+
+Here is what the output looks like for a typical run:
+
+```text
+prompt> ./mem 1000
+allocating 1048576000 bytes (1000.00 MB)
+  number of integers in array: 262144000
+loop 0 in 448.11 ms (bandwidth: 2231.61 MB/s)
+loop 1 in 345.38 ms (bandwidth: 2895.38 MB/s)
+loop 2 in 345.18 ms (bandwidth: 2897.07 MB/s)
+loop 3 in 345.23 ms (bandwidth: 2896.61 MB/s)
+^C
+prompt>
+```
+
+The program first tells you how much memory it allocated (in bytes, MB, and in
+the number of integers), and then starts looping through the array. The first
+loop (in the example above) took 448 milliseconds; because the program
+accessed the 1000 MB in just under half a second, the computed bandwidth is
+(not surprisingly) just over 2000 MB/s.
+
+The program continues by doing the same thing over and over, for loops 1, 2,
+etc.
+
+Important: to stop the program, you must kill it. This task is accomplished on
+Linux (and all Unix-based systems) by typing control-C (^C) as shown above.
+
+Note that when you run with small array sizes, each loop's performance numbers
+won't be printed. For example:
+
+```text
+prompt>  ./mem 1
+allocating 1048576 bytes (1.00 MB)
+  number of integers in array: 262144
+loop 0 in 0.71 ms (bandwidth: 1414.61 MB/s)
+loop 607 in 0.33 ms (bandwidth: 3039.35 MB/s)
+loop 1215 in 0.33 ms (bandwidth: 3030.57 MB/s)
+loop 1823 in 0.33 ms (bandwidth: 3039.35 MB/s)
+^C
+prompt>
+```
+
+In this case, the program only prints out a sample of outputs, so as not to
+flood the screen with too much output.
+
+The code itself is simple to understand. The first important part is a memory
+allocation:
+
+```c
+    // the big memory allocation happens here
+    int *x = malloc(size_in_bytes);
+```
+
+Then, the main loop begins:
+
+```c
+    while (1) {
+	x[i++] += 1; // main work of loop done here.
+```
+
+The rest is just timing and printing out information. See mem.c for details.
+
+Much of the homework revolves around using the tool vmstat to monitor what is
+happening with the system. Read the vmstat man page (type "man vmstat") for
+details on how it works, and what each column of output means.

hw4/simu2/mem.c

@@ -0,0 +1,67 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <sys/time.h>
+
+// Simple routine to return absolute time (in seconds).
+double Time_GetSeconds() {
+    struct timeval t;
+    int rc = gettimeofday(&t, NULL);
+    assert(rc == 0);
+    return (double) ((double)t.tv_sec + (double)t.tv_usec / 1e6);
+}
+
+// Program that allocates an array of ints of certain size,
+// and then proceeeds to update each int in a loop, forever.
+int main(int argc, char *argv[]) {
+    if (argc != 2) {
+	fprintf(stderr, "usage: spin <memory (MB)>\n");
+	exit(1);
+    }
+    long long int size = (long long int) atoi(argv[1]);
+    long long int size_in_bytes = size * 1024 * 1024;
+
+    printf("allocating %lld bytes (%.2f MB)\n", 
+	   size_in_bytes, size_in_bytes / (1024 * 1024.0));
+
+    // the big memory allocation happens here
+    int *x = malloc(size_in_bytes);
+    if (x == NULL) {
+	fprintf(stderr, "memory allocation failed\n");
+	exit(1);
+    }
+
+    long long int num_ints = size_in_bytes / sizeof(int);
+    printf("  number of integers in array: %lld\n", num_ints);
+
+    // now the main loop: each time through, touch each integer
+    // (and increment its value by 1).
+    int i = 0;
+    double time_since_last_print = 2.0; 
+    double t = Time_GetSeconds();
+    int loop_count = 0;
+    while (1) {
+	x[i++] += 1; // main work of loop done here.
+
+	// if we've gone through the whole loop, reset a bunch of stuff
+	// and then (perhaps) print out some statistics. 
+	if (i == num_ints) {
+	    double delta_time = Time_GetSeconds() - t;
+	    time_since_last_print += delta_time;
+	    if (time_since_last_print >= 0.2) { // only print every .2 seconds
+		printf("loop %d in %.2f ms (bandwidth: %.2f MB/s)\n", 
+		       loop_count, 1000 * delta_time, 
+		       size_in_bytes / (1024.0*1024.0*delta_time));
+		time_since_last_print = 0;
+	    }
+
+	    i = 0;
+	    t = Time_GetSeconds();
+	    loop_count++;
+	}
+    }
+
+    return 0;
+}
+

hw4/simu3/ANSWERS.md

@@ -0,0 +1,18 @@
+# hw4 - Simulation 3 - Antworten
+
+1.
+    1. FIFO: Da immer das älteste Element aus dem Cache geworfen wird, verursacht `1,2,3,4,5,6,1,2,...` ausschließlich Cache-Misses.
+    2. LRU: Nun wird immer das am längsten nicht getroffene Element aus dem Cache geworfen. Die Strategie bei FIFO funktioniert auch hier.
+    3. MRU: Hier funktioniert die bisher verwendete Folge nicht mehr. Da immer das zuletzt verwendete Element aus dem Cache entfernt wird, ist `1,2,3,4,5,6,5,6,...` eine Möglichkeit, um ausschließlich Cache-Misses zu provozieren. Die Folge `1-6` dient dabei dazu, den Cache zuerst aufzufüllen.
+    4. Für unseren Fall (eine Abfolge von 6 verschiedenen Zugriffen) braucht der Cache eine minimale Größe von 6, um sehr viel mehr Cache-Hits zu erreichen. Um genau zu sein, sind dann immer alle Einträge im Cache vorhanden, und nach der anfänglichen Auffüllphase (in der nur Misses auftreten) ist jeder Zugriff ein Hit.
+
+2. Für unser Programm, siehe `randomtrace.c`.
+    1. Wir erwarten, dass sich die verschiedenen Policies entsprechend dem, wie wir es in der Vorlesung besprochen hatten, verhalten.
+
+3. *Traces* mit *locality*:
+
+    i. Um räumliche Lokalität (spatial locality) herzustellen darf man die TLB Abdeckung nicht überschreiten bzw. müssen Zahlen gewählt werden, die in der Nähe von einander liegen. Zusätzlich kann man zeitliche Lokalität erzeugen, in dem sich Zahlen wiederholen (temporal locality). Das bedeutet 1,2,2,3,2,3,2,3,2,3,2,2,2,2 ist von räumlicher und zeitlicher Lokalität.
+
+    ii. LRU hatte beim Auruf mit solchen traces eine Hitrate von ca. 80%
+
+    iii. Mit der Policy RAND gab es trotzdem immer die selbe Hitrate wie mit LRU...

hw4/simu3/QUESTIONS.md

@@ -0,0 +1,19 @@
+# Questions 20-paging-multilevel-translate
+
+This simulator, paging-policy.py, allows you to play around with different page-replacement policies. See the README for details.
+
+## Warmup
+
+Generate random addresses with the following arguments: -s 0 -n 10, -s 1 -n 10, and -s 2 -n 10. Change the policy from FIFO,to LRU, to OPT. Compute whether each access in said address traces are hits or misses.
+
+## Questions
+
+1. For a cache of size 5, generate worst-case address reference streams for each of the following policies: FIFO, LRU, and MRU (worst-case reference streams cause the most misses possible. For the worst case reference streams, how much bigger of a cache is needed to improve performance dramatically and approach OPT?
+
+1. Generate a random trace (use python or c or rust (single file, no project).
+    1. How would you expect the different policies to perform on such a trace?
+1. Now generate a trace with some locality.
+    1. How can you generate such a trace?
+    1. How does LRU perform on it?
+    1. How much better than RAND is LRU?
+    1. How does CLOCK do? How about CLOCK with different numbers of clock bits?

hw4/simu3/README-paging-policy.md

@@ -0,0 +1,128 @@
+# README Paging: Policy
+
+This simulator, paging-policy.py, allows you to play around with different
+page-replacement policies. For example, let's examine how LRU performs with a
+series of page references with a cache of size 3:
+
+```text
+  0 1 2 0 1 3 0 3 1 2 1
+```
+
+To do so, run the simulator as follows:
+
+```text
+prompt> ./paging-policy.py --addresses=0,1,2,0,1,3,0,3,1,2,1
+                           --policy=LRU --cachesize=3 -c
+```text
+
+And what you would see is:
+
+```text
+ARG addresses 0,1,2,0,1,3,0,3,1,2,1
+ARG numaddrs 10
+ARG policy LRU
+ARG cachesize 3
+ARG maxpage 10
+ARG seed 0
+
+Solving...
+
+Access: 0 MISS LRU->      [br 0]<-MRU Replace:- [br Hits:0 Misses:1]
+Access: 1 MISS LRU->   [br 0, 1]<-MRU Replace:- [br Hits:0 Misses:2]
+Access: 2 MISS LRU->[br 0, 1, 2]<-MRU Replace:- [br Hits:0 Misses:3]
+Access: 0 HIT  LRU->[br 1, 2, 0]<-MRU Replace:- [br Hits:1 Misses:3]
+Access: 1 HIT  LRU->[br 2, 0, 1]<-MRU Replace:- [br Hits:2 Misses:3]
+Access: 3 MISS LRU->[br 0, 1, 3]<-MRU Replace:2 [br Hits:2 Misses:4]
+Access: 0 HIT  LRU->[br 1, 3, 0]<-MRU Replace:2 [br Hits:3 Misses:4]
+Access: 3 HIT  LRU->[br 1, 0, 3]<-MRU Replace:2 [br Hits:4 Misses:4]
+Access: 1 HIT  LRU->[br 0, 3, 1]<-MRU Replace:2 [br Hits:5 Misses:4]
+Access: 2 MISS LRU->[br 3, 1, 2]<-MRU Replace:0 [br Hits:5 Misses:5]
+Access: 1 HIT  LRU->[br 3, 2, 1]<-MRU Replace:0 [br Hits:6 Misses:5]
+```
+
+The complete set of possible arguments for paging-policy is listed on the
+following page, and includes a number of options for varying the policy, how
+addresses are specified/generated, and other important parameters such as the
+size of the cache.
+
+```text
+prompt> ./paging-policy.py --help
+Usage: paging-policy.py [options]
+
+Options:
+-h, --help      show this help message and exit
+-a ADDRESSES, --addresses=ADDRESSES
+                a set of comma-separated pages to access;
+                -1 means randomly generate
+-f ADDRESSFILE, --addressfile=ADDRESSFILE
+                a file with a bunch of addresses in it
+-n NUMADDRS, --numaddrs=NUMADDRS
+                if -a (--addresses) is -1, this is the
+                number of addrs to generate
+-p POLICY, --policy=POLICY
+                replacement policy: FIFO, LRU, LFU, OPT,
+                                    UNOPT, RAND, CLOCK
+-b CLOCKBITS, --clockbits=CLOCKBITS
+                for CLOCK policy, how many clock bits to use
+-C CACHESIZE, --cachesize=CACHESIZE
+                size of the page cache, in pages
+-m MAXPAGE, --maxpage=MAXPAGE
+                if randomly generating page accesses,
+                this is the max page number
+-s SEED, --seed=SEED  random number seed
+-N, --notrace   do not print out a detailed trace
+-c, --compute   compute answers for me
+```
+
+As usual, "-c" is used to solve a particular problem, whereas without it, the
+accesses are just listed (and the program does not tell you whether or not a
+particular access is a hit or miss).
+
+To generate a random problem, instead of using "-a/--addresses" to pass in
+some page references, you can instead pass in "-n/--numaddrs" as the number of
+addresses the program should randomly generate, with "-s/--seed" used to
+specify a different random seed. For example:
+
+```text
+prompt> ./paging-policy.py -s 10 -n 3
+.. .
+
+Assuming a replacement policy of FIFO, and a cache of size 3 pages,
+figure out whether each of the following page references hit or miss
+in the page cache.
+
+Access: 5  Hit/Miss?  State of Memory?
+Access: 4  Hit/Miss?  State of Memory?
+Access: 5  Hit/Miss?  State of Memory?
+```
+
+As you can see, in this example, we specify "-n 3" which means the program
+should generate 3 random page references, which it does: 5, 7, and 5. The
+random seed is also specified (10), which is what gets us those particular
+numbers. After working this out yourself, have the program solve the problem
+for you by passing in the same arguments but with "-c" (showing just the
+relevant part here):
+
+```text
+prompt> ./paging-policy.py -s 10 -n 3 -c
+...
+Solving...
+
+Access: 5 MISS FirstIn->   [br 5] <-Lastin Replace:- [br Hits:0 Misses:1]
+Access: 4 MISS FirstIn->[br 5, 4] <-Lastin Replace:- [br Hits:0 Misses:2]
+Access: 5 HIT  FirstIn->[br 5, 4] <-Lastin Replace:- [br Hits:1 Misses:2]
+```
+
+The default policy is FIFO, though others are available, including LRU, MRU,
+OPT (the optimal replacement policy, which peeks into the future to see what
+is best to replace), UNOPT (which is the pessimal replacement), RAND (which
+does random replacement), and CLOCK (which does the clock algorithm). The
+CLOCK algorithm also takes another argument (-b), which states how many bits
+should be kept per page; the more clock bits there are, the better the
+algorithm should be at determining which pages to keep in memory.
+
+Other options include: "-C/--cachesize" which changes the size of the page
+cache; "-m/--maxpage" which is the largest page number that will be used if
+the simulator is generating references for you; and "-f/--addressfile" which
+lets you specify a file with addresses in them, in case you wish to get traces
+from a real application or otherwise use a long trace as input.

hw4/simu3/paging-policy.py

@@ -0,0 +1,275 @@
+#! /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
+
+def hfunc(index):
+    if index == -1:
+        return 'MISS'
+    else:
+        return 'HIT '
+
+def vfunc(victim):
+    if victim == -1:
+        return '-'
+    else:
+        return str(victim)
+
+#
+# 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('-f', '--addressfile', default='',   help='a file with a bunch of addresses in it',                                action='store', type='string', dest='addressfile')
+parser.add_option('-n', '--numaddrs', default='10',    help='if -a (--addresses) is -1, this is the number of addrs to generate',    action='store', type='string', dest='numaddrs')
+parser.add_option('-p', '--policy', default='FIFO',    help='replacement policy: FIFO, LRU, OPT, UNOPT, RAND, CLOCK',                action='store', type='string', dest='policy')
+parser.add_option('-b', '--clockbits', default=2,      help='for CLOCK policy, how many clock bits to use',                          action='store', type='int', dest='clockbits')
+parser.add_option('-C', '--cachesize', default='3',    help='size of the page cache, in pages',                                      action='store', type='string', dest='cachesize')
+parser.add_option('-m', '--maxpage', default='10',     help='if randomly generating page accesses, this is the max page number',     action='store', type='string', dest='maxpage')
+parser.add_option('-s', '--seed', default='0',         help='random number seed',                                                    action='store', type='string', dest='seed')
+parser.add_option('-N', '--notrace', default=False,    help='do not print out a detailed trace',                                     action='store_true', dest='notrace')
+parser.add_option('-c', '--compute', default=False,    help='compute answers for me',                                                action='store_true', dest='solve')
+
+(options, args) = parser.parse_args()
+
+print 'ARG addresses', options.addresses
+print 'ARG addressfile', options.addressfile
+print 'ARG numaddrs', options.numaddrs
+print 'ARG policy', options.policy
+print 'ARG clockbits', options.clockbits
+print 'ARG cachesize', options.cachesize
+print 'ARG maxpage', options.maxpage
+print 'ARG seed', options.seed
+print 'ARG notrace', options.notrace
+print ''
+
+addresses   = str(options.addresses)
+addressFile = str(options.addressfile)
+numaddrs    = int(options.numaddrs)
+cachesize   = int(options.cachesize)
+seed        = int(options.seed)
+maxpage     = int(options.maxpage)
+policy      = str(options.policy)
+notrace     = options.notrace
+clockbits   = int(options.clockbits)
+
+random.seed(seed)
+
+addrList = []
+if addressFile != '':
+    fd = open(addressFile)
+    for line in fd:
+        addrList.append(int(line))
+    fd.close()
+else:
+    if addresses == '-1':
+        # need to generate addresses
+        for i in range(0,numaddrs):
+            n = int(maxpage * random.random())
+            addrList.append(n)
+    else:
+        addrList = addresses.split(',')
+
+if options.solve == False:
+    print 'Assuming a replacement policy of %s, and a cache of size %d pages,' % (policy, cachesize)
+    print 'figure out whether each of the following page references hit or miss'
+    print 'in the page cache.\n'
+
+    for n in addrList:
+        print 'Access: %d  Hit/Miss?  State of Memory?' % int(n)
+    print ''
+
+else:
+    if notrace == False:
+        print 'Solving...\n'
+
+    # init memory structure
+    count = 0
+    memory = []
+    hits = 0
+    miss = 0
+
+    if policy == 'FIFO':
+        leftStr = 'FirstIn'
+        riteStr = 'Lastin '
+    elif policy == 'LRU':
+        leftStr = 'LRU'
+        riteStr = 'MRU'
+    elif policy == 'MRU':
+        leftStr = 'LRU'
+        riteStr = 'MRU'
+    elif policy == 'OPT' or policy == 'RAND' or policy == 'UNOPT' or policy == 'CLOCK':
+        leftStr = 'Left '
+        riteStr = 'Right'
+    else:
+        print 'Policy %s is not yet implemented' % policy
+        exit(1)
+
+    # track reference bits for clock
+    ref   = {}
+
+    cdebug = False
+
+    # need to generate addresses
+    addrIndex = 0
+    for nStr in addrList:
+        # first, lookup
+        n = int(nStr)
+        try:
+            idx = memory.index(n)
+            hits = hits + 1
+            if policy == 'LRU' or policy == 'MRU':
+                update = memory.remove(n)
+                memory.append(n) # puts it on MRU side
+        except:
+            idx = -1
+            miss = miss + 1
+
+        victim = -1        
+        if idx == -1:
+            # miss, replace?
+            # print 'BUG count, cachesize:', count, cachesize
+            if count == cachesize:
+                # must replace
+                if policy == 'FIFO' or policy == 'LRU':
+                    victim = memory.pop(0)
+                elif policy == 'MRU':
+                    victim = memory.pop(count-1)
+                elif policy == 'RAND':
+                    victim = memory.pop(int(random.random() * count))
+                elif policy == 'CLOCK':
+                    if cdebug:
+                        print 'REFERENCE TO PAGE', n
+                        print 'MEMORY ', memory
+                        print 'REF (b)', ref
+
+                    # hack: for now, do random
+                    # victim = memory.pop(int(random.random() * count))
+                    victim = -1
+                    while victim == -1:
+                        page = memory[int(random.random() * count)]
+                        if cdebug:
+                            print '  scan page:', page, ref[page]
+                        if ref[page] >= 1:
+                            ref[page] -= 1
+                        else:
+                            # this is our victim
+                            victim = page
+                            memory.remove(page)
+                            break
+
+                    # remove old page's ref count
+                    if page in memory:
+                        assert('BROKEN')
+                    del ref[victim]
+                    if cdebug:
+                        print 'VICTIM', page
+                        print 'LEN', len(memory)
+                        print 'MEM', memory
+                        print 'REF (a)', ref
+
+                elif policy == 'OPT':
+                    maxReplace  = -1
+                    replaceIdx  = -1
+                    replacePage = -1
+                    # print 'OPT: access %d, memory %s' % (n, memory) 
+                    # print 'OPT: replace from FUTURE (%s)' % addrList[addrIndex+1:]
+                    for pageIndex in range(0,count):
+                        page = memory[pageIndex]
+                        # now, have page 'page' at index 'pageIndex' in memory
+                        whenReferenced = len(addrList)
+                        # whenReferenced tells us when, in the future, this was referenced
+                        for futureIdx in range(addrIndex+1,len(addrList)):
+                            futurePage = int(addrList[futureIdx])
+                            if page == futurePage:
+                                whenReferenced = futureIdx
+                                break
+                        # print 'OPT: page %d is referenced at %d' % (page, whenReferenced)
+                        if whenReferenced >= maxReplace:
+                            # print 'OPT: ??? updating maxReplace (%d %d %d)' % (replaceIdx, replacePage, maxReplace)
+                            replaceIdx  = pageIndex
+                            replacePage = page
+                            maxReplace  = whenReferenced
+                            # print 'OPT: --> updating maxReplace (%d %d %d)' % (replaceIdx, replacePage, maxReplace)
+                    victim = memory.pop(replaceIdx)
+                    # print 'OPT: replacing page %d (idx:%d) because I saw it in future at %d' % (victim, replaceIdx, whenReferenced)
+                elif policy == 'UNOPT':
+                    minReplace  = len(addrList) + 1
+                    replaceIdx  = -1
+                    replacePage = -1
+                    for pageIndex in range(0,count):
+                        page = memory[pageIndex]
+                        # now, have page 'page' at index 'pageIndex' in memory
+                        whenReferenced = len(addrList)
+                        # whenReferenced tells us when, in the future, this was referenced
+                        for futureIdx in range(addrIndex+1,len(addrList)):
+                            futurePage = int(addrList[futureIdx])
+                            if page == futurePage:
+                                whenReferenced = futureIdx
+                                break
+                        if whenReferenced < minReplace:
+                            replaceIdx  = pageIndex
+                            replacePage = page
+                            minReplace  = whenReferenced
+                    victim = memory.pop(replaceIdx)
+            else:
+                # miss, but no replacement needed (cache not full)
+                victim = -1
+                count = count + 1
+
+            # now add to memory
+            memory.append(n)
+            if cdebug:
+                print 'LEN (a)', len(memory)
+            if victim != -1:
+                assert(victim not in memory)
+
+        # after miss processing, update reference bit
+        if n not in ref:
+            ref[n] = 1
+        else:
+            ref[n] += 1
+            if ref[n] > clockbits:
+                ref[n] = clockbits
+        
+        if cdebug:
+            print 'REF (a)', ref
+
+        if notrace == False:
+            print 'Access: %d  %s %s -> %12s <- %s Replaced:%s [Hits:%d Misses:%d]' % (n, hfunc(idx), leftStr, memory, riteStr, vfunc(victim), hits, miss)
+        addrIndex = addrIndex + 1
+        
+    print ''
+    print 'FINALSTATS hits %d   misses %d   hitrate %.2f' % (hits, miss, (100.0*float(hits))/(float(hits)+float(miss)))
+    print ''
+
+
+
+    
+    
+    
+
+
+
+
+
+
+

hw4/simu3/randomtrace.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int main(int argc, char* argv[]) {
+  srand(time(NULL));
+
+  if (argc != 3) {
+    fprintf(stderr, "Usage: ./randomtrace <count> <size>\n");
+    return -1;
+  }
+
+  int i, r, s, t;
+  s = atoi(argv[1]);
+  t = atoi(argv[2]);
+  for (i = 0; i < s; i++) {
+    r = (int) (rand() % t);
+    if (i != s - 1) {
+      printf("%d,", r);
+    } else {
+      printf("%d", r);
+    }
+  }
+  printf("\n");
+}

hw4/task1/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "task1"
+version = "0.1.0"
+authors = ["Lorenz Bung & Joshua Rutschmann"]
+
+[dependencies]
+procinfo = "^0.4.2"
+libc = "^0.2"

hw4/task1/README.md

@@ -0,0 +1,277 @@
+# Homework hw4 task1
+
+- [Überblick](#%C3%BCberblick)
+- [Daten aus dem /proc Verzeichnis lesen](#daten-aus-dem-proc-verzeichnis-lesen)
+- [Externe Crate nutzen](#externe-crate-nutzen)
+- [Optionalen Parameter parsen](#optionalen-parameter-parsen)
+- [Aufgaben](#aufgaben)
+    - [Externe Crate in Dependencies eintragen](#externe-crate-in-dependencies-eintragen)
+    - [`readproc.rs`: Eigene Prozessinformationen auslesen](#readprocrs-eigene-prozessinformationen-auslesen)
+    - [`pstree.rs`: Prozesskette ausgeben](#pstreers-prozesskette-ausgeben)
+- [Kontrolle Ihres Repositories](#kontrolle-ihres-repositories)
+
+## Überblick
+
+Ziel dieser Aufgabe ist es, mittels des externen Crates `procinfo` einige
+Prozessverwaltungs-Informationen kennen zu lernen, die das Betriebssystem beim
+Ausführen der Prozesse verwaltet. Fertige Programme wie **ps**, **htop** oder
+**pmap** verwenden diese Informationen, um über das System und Tasks Auskunft zu
+geben.
+
+Die Funktionalität der Programms wird auf die 3 Module aufgeteilt:
+
+- `main.rs`: die Funktion `main()
+- `readproc.rs`: Handling der Funktionen, die angefragte Informationen aus dem
+  `proc/` Verzeichnis zu Verfügung stellen.
+- `pstree.rs`: Struct und Methoden, um einen 'pstree' darzustellen
+
+## Daten aus dem /proc Verzeichnis lesen
+
+"Das `/proc`-Verzeichnis ist kein wirkliches Dateisystem, sondern eine
+Schnittstelle zum Kernel. Die Dateien, die in diesem Verzeichnis liegen,
+benutzen keinen Speicherplatz auf der Platte, sind aber trotzdem les- und in
+manchen Fällen auch beschreibbar.
+
+Seinen Namen trägt dieses Verzeichnis daher, dass es für jeden laufenden Prozess
+ein Unterverzeichnis bereithält, das Informationen über diesen Prozess zur
+Verfügung stellt. Das Unterverzeichnis trägt als Namen die ProzessID (PID) des
+jeweiligen Prozesses. Es enthält unter anderem folgende Dateien:
+
+- `cmdline` Die Kommandozeile, mit der der Prozess gestartet wurde, mit allen
+  verwendeten Parametern.
+- `cwd` (current working directory) Ein symbolischer Link auf das Verzeichnis,
+  das beim Aufruf des Prozesses das aktuelle Arbeitsverzeichnis war.
+- `environ` Die komplette Umgebung des Prozesses (Variablen, Funktionen usw.)
+  sofern er eine Umgebung hat.
+- `exe` Ein symbolischer Link auf das aufgerufene Programm, dass den Prozess
+  ausmacht.
+- `root` Ein symbolischer Link auf das Verzeichnis, das für den Prozess das
+  Wurzelverzeichnis darstellt.
+
+Daneben finden sich weitere Informationen zu den verwendeten Ressourcen
+(Speicher, Libraries) und ein Unterverzeichnis **fd**, das die File-Descriptoren
+aller vom Prozess verwendeten Dateien enthält.
+
+Diese Information wird beispielsweise von den Programmen verwertet, die
+Prozess-Informationen ausgeben." (aus [Referenz][])
+
+Das `/proc` Verzeichnis steht nur unter Linux zu Verfügung. Daher müssen
+Programme, die auf `/proc` zugreifen auch auf einem Linux System erstellt und
+getestet werden.
+
+## Externe Crate nutzen
+
+Um nicht selbst im Programm auf die nötigen Dateien per File E/A im ´/proc´
+zugreifen zu müssen, wird zum Auslesen eine externe Crate benutzt. Die Crate
+*[procinfo][]* stellt dazu die nötigen Funktionen zu Verfügung. Die Funktionen
+liefern in einem Result eine Datenstruktur, aus der wir die benötigten
+Informationen komfortabel auslesen können. Verwenden Sie in Ihrem Programm
+soweit wie möglich die Funktionen des externen Crates *procinfo*, auch wenn in
+der Standard-Bibliothek ebenfalls Funktionen für einzelne Aufgaben zu Verfügung
+stehen.
+
+## Optionalen Parameter parsen
+
+Der Optionale Parameter PID (u32) entscheidet darüber, ob Ihr Programm die
+Funktionen des Moduls `readproc.rs` oder `pstree.rs` verwendet. Wird kein
+Parameter angegeben, so werden die Funktionen des Moduls `readproc.rs` benutzt.
+
+## Aufgaben
+
+### Externe Crate in Dependencies eintragen
+
+- Benutzen Sie für die folgenden Aufgaben das *[procinfo][]* Crate.
+- Fügen Sie dazu den notwendigen Eintrag unter `[dependencies]` in
+  **Cargo.toml** hinzu.
+- Um auf die nötige Funktionen des Crate zugreifen zu können schreiben Sie NUR
+  in **main.rs** bitte folgenden Zeilen an den Beginn der Datei:
+
+ ```Rust
+ extern crate procinfo;
+ ```
+
+Benutzen Sie in Ihren Modulen `readproc.rs` und `pstree.rs` die `use` Anweisung
+geeignet, um auf die nötigen Funktionen des Crate *procinfo* in den Modulen
+zugreifen zu können.
+
+In der Crate *procinfo* wird als Return ein Result Typ mit nur dem OK Typ
+benutzt. Der Err Typ ist scheinbar nicht im Result enthalten. Wenn man
+allerdings die Info der Standardbibliothek zu [io::Result][] liest, erfährt man,
+dass es sich hier um einen Alias handelt, der komfortableres Arbeiten mit Errors
+erlaubt. Dazu kommen wir aber erst in späteren Kapiteln, wenn wir uns dem `?`
+Makro nähern. Daher bitte hier in der Aufgabe noch keine Makros wie `try` und
+`?` benutzen.
+
+### `readproc.rs`: Eigene Prozessinformationen auslesen
+
+Ziel dieser Teilaufgabe ist es das Crate *procinfo* kennen zu lernen und sich
+noch ein wenig mit dem Return Typ 'Result' und der Fehlerbehandlung zu üben.
+
+Die folgenden Funktionen werden im Modul `readproc.rs` implementiert. Alle
+Funktionen reichen mögliche Fehler über einen Result zurück zur aufrufenden
+Funktion. Keine der Funktionen darf im Fehlerfall einen Programmabbruch
+erzwingen.
+
+1. Schreiben Sie die Funktion `fn self_pids() -> Result<(i32, i32), &'static
+   str>`, die die eigene PID und die PPID in einem Tupel (PID,PPID) Im
+   Erfolgsfall zurückgibt.
+
+   > Hinweis: Überlegen Sie sich, ob `stat()` und der `stat_self()` die
+   > geeignetere Funktion im *procinfo* Crate für diesen Fall ist.
+
+1. Schreiben Sie die Funktion `fn get_pid_command(pid: i32) -> Result<String,
+   &'static str>`, die den Command Namen zu einer PID zurück liefert. Wird die
+   PID nicht gefunden im System, so soll die Funktion den String "PID not alive:
+   no command name found" zurück geben.
+
+1. Schreiben Sie die Funktion `fn get_last_created_command() -> Result<String,
+   &'static str>`, die den Command Namen des zuletzt erzeugten Prozesses im
+   System zurück gibt. Wird die PID nicht gefunden im System, so soll die
+   Funktion den String "No last command via PID found" zurück geben.
+
+   > Tip: `loadavg()` Funktion.
+
+1. Schreiben Sie die Funktion `fn get_thread_count(pid: i32) -> Result<u32,
+   &'static str>`, die die Anzahl der Threads pro PID zurückliefert. Wird die
+   PID nicht gefunden im System, so soll die Funktion den String "PID not alive:
+   no threads counted" zurück geben.
+
+1. Benutzen Sie nun Ihre Funktionen geeignet, um in Ihrer `main()` Funktion
+   folgende Ausgaben zu produzieren:
+
+   ```text
+    My PID : 31894 - process1 running 4 threads
+    My PPID: 27952 - process2 running 2 threads
+    Last process created in system was: process3
+   ```
+
+   > Hinweis: Die Nummer und Command Namen sind bei Ihnen verschieden. Wenn Sie
+   > Probleme beim Aufruf Ihres Programms über **cargo run** haben lesen Sie
+   > unbedingt die nächste Frage!
+
+1. Sie können Ihr Programm über:
+
+   - **cargo run** oder
+   - **./target/debug/task1** starten.
+
+   Überlegen Sie sich, wie es zu den unterschiedlichen Ausgaben und
+   Programmverhalten kommt.
+
+1. Schreiben Sie die Funktion `fn get_task_total() -> Result<u32, &'static
+   str>`, die die Gesamtmenge aller Tasks im System zurück liefert. Wird die
+   Gesamtmenge nicht gefunden, so soll die Funktion den String "No total count
+   of tasks in system found" zurück geben.
+
+   > Warum z.B. zeigt Ihnen das Programm **htop** eine andere Anzahl von
+   > Prozessen als Ihre ausgelesene Funktion?
+
+1. Schreiben Sie die Funktion `fn get_ownprocess_mem() ->
+   Result<(usize,usize,usize), &'static str>`, die in einem Tuple die Werte für:
+
+   - vsize
+   - code und
+   - data
+
+   zurück liefert.
+
+1. Im Modul `main.rs` produzieren Sie die Ausgabe für die Kommandozeile und
+   kümmern sich um evtl. Fehler. Bei korrektem Programmablauf ergibt sich
+   folgende Ausgabe (genau 5 Zeilen!):
+
+   ```text
+   My PID : 31894 - process1 running 4 threads
+   My PPID: 27952 - process2 running 2 threads
+   My mem : 3560 (vspace), 208 (code), 588 (data)
+   Last process created in system was: process3
+   Total number of tasks: 145
+   ```
+
+### `pstree.rs`: Prozesskette ausgeben
+
+1. Auf Basis des Crate *procinfo* sollen Sie bei Aufruf des Programms mit einer
+   PID, ausgehend von dieser PID der Tree bis zum aktuellen Programm ausgegeben
+   werden. Wird somit als Argument eine `1` angegeben, wird eine Funktionalität
+   des Kommandozeilen Programms **pstree / pstree.x11** nachgebildet. Wenn Sie sich z.B. mit
+   dem Kommando **ps** die PID Ihrer aktuellen Shell anzeigen lassen, können Sie
+   sich durch Aufruf von **pstree.x11 -p -s <pid>** die Kette aller Prozesse
+   anzeigen lassen, in denen die <pid> enthalten ist.
+
+   ```text
+   systemd(1)---sshd(1264)---sshd(7161)---sshd(7198)---zsh(7199)---pstree.x11(47200)
+   ```
+
+   Genau diese Ausgabe soll nun Ihr Programm erzeugen bei der Option '1', wobei
+   natürlich das Ende der Kette nicht mehr `pstree.x11` ist sondern Ihr Programm.
+
+   Geben Sie im obigen Beispiel die PID 7161 als Parameter an, so soll Ihr Programm
+   nur den Teil-Tree ausgegeben, startend vom Prozess mit PID 7161.
+
+   ```text
+   sshd(7161)---sshd(7198)---zsh(7199)---task1(47200)
+   ```
+
+   Ausgehend von der eigenen pid sollen alle Elternpid bis zum übergebenen PID
+   (z.B. 1 für init Prozess, hier `systemd`) angezeigt werden. Der Init Prozess
+   (hier systemd) hat immer die PID 1 in UNIX Systemen, aber unterschiedliche Namen.
+
+1. Nutzen Sie zum parsen der PID im Argument die `parse()` Funktion. Behandeln
+   Sie folgende Fehler:
+
+   - Parameter ist keine Zahl
+   - Parameter ist keine Elternpid
+   - Mehr als 2 Parameter werden bei Aufruf mit angegeben.
+
+   Geben Sie im Fehlerfall eine entsprechende Meldung in einer(1!) Zeile aus und
+   beenden Sie das Programm mit dem Exitcode 1. Eine möglich Ausgabe:
+
+   ```text
+   $ ./task1 2 3
+   Correct usage: no param or param PID
+   ```
+
+   >Wichtig: Im Fehlerfall beenden Sie das Programm kontrolliert mit exit(1).
+   >Den Fehlercode '1' überprüfen die Tests in tests/output.bats!
+
+1. Erstellen Sie eine eigene Datenstruktur und Methoden um die Aufgabe zu lösen.
+   Verwenden Sie nur die externe Crate *procinfo* dazu. Die Ausgabe beim Aufruf
+   Ihres Programms muss folgender Beispielformatierung entsprechen:
+
+    ```text
+    systemd(1)---sshd(1264)---sshd(7161)---sshd(7198)---zsh(7199)---task1(47151)
+    ```
+   > Je nachdem wie Sie Ihr Programm aufrufen wird es natürlich andere Ausgaben
+   > produzieren. Durch das Kommandozeilen-Tool **pstree.x11** können Sie Ihre
+   > Ausgabe kontrollieren!
+
+1. Schreiben Sie eine eigene unit Test Datei `unit_test_pstree.rs`, die Ihre
+   Funktionen im Modul `pstree.rs` geeignet testet und beim Aufruf von **cargo
+   test** die Tests ausführt.
+
+1. Schreiben Sie ausreichend Kommentare, um Ihre Implementierung in `pstree.rs`
+   über die per **cargo doc** erstellten Dokumentation nachvollziehen zu können.
+
+## Kontrolle Ihres Repositories
+
+Haben Sie die Aufgaben komplett bearbeitet, so sollten sich folgende Dateien in
+Ihrem Projekt-Verzeichnis befinden:
+
+```text
+.
+├── Cargo.lock
+├── Cargo.toml
+├── README.md
+├── src
+│   ├── main.rs
+│   ├── pstree.rs
+│   ├── readproc.rs
+│   ├── unit_test_pstree.rs
+│   └── unit_test_readproc.rs
+└── tests
+    └── output.bats
+
+2 directories, 9 files
+```
+
+[Referenz]: http://www.linux-praxis.de/lpic1/lpi101/proc.html
+[procinfo]: https://docs.rs/procinfo/
+[io::Result]: https://doc.rust-lang.org/std/io/type.Result.html

hw4/task1/src/main.rs

@@ -0,0 +1,95 @@
+extern crate procinfo;
+
+use std::env;
+use std::process;
+
+mod readproc;
+mod pstree;
+
+mod unit_test_pstree;
+mod unit_test_readproc;
+
+/// Mainfunction
+fn main() {
+
+    let args: Vec<String> = env::args().collect();
+
+    match args.len() {
+        1 => {
+            if let Ok(pid_tuple) = readproc::self_pids() {
+                let pid = pid_tuple.0;
+                let ppid = pid_tuple.1;
+
+                // Commands & Threads for PID
+                if let Ok(pid_command) = readproc::get_pid_command(pid) {
+                    if let Ok(pid_threads) = readproc::get_thread_count(pid) {
+                        println!(
+                            "My PID : {} - {} running {} threads",
+                            pid,
+                            pid_command,
+                            pid_threads
+                        );
+                    }
+                }
+
+                // Commands & Threads for Parent-PID
+                if let Ok(ppid_command) = readproc::get_pid_command(ppid) {
+                    if let Ok(ppid_threads) = readproc::get_thread_count(ppid) {
+                        println!(
+                            "My PPID: {} - {} running {} threads",
+                            ppid,
+                            ppid_command,
+                            ppid_threads
+                        );
+                    }
+                }
+
+            }
+
+
+            if let Ok(size_tuple) = readproc::get_ownprocess_mem() {
+                // Memory
+                let vspace = size_tuple.0;
+                let code = size_tuple.1;
+                let data = size_tuple.2;
+
+                println!(
+                    "My mem : {} (vspace), {} (code), {} (data)",
+                    vspace,
+                    code,
+                    data
+                );
+            }
+
+            if let Ok(last_command) = readproc::get_last_created_command() {
+                // Last Process
+                println!("Last process created in system was: {}", last_command);
+            }
+
+
+            if let Ok(task_total) = readproc::get_task_total() {
+                // Number of tasks
+                println!("Total number of tasks: {}", task_total);
+            }
+        }
+
+        2 => {
+            match args[1].parse::<i32>() {
+                Ok(pid) => {
+                    if !pstree::print(pid) {
+                        process::exit(1);
+                    }
+                }
+                Err(_) => {
+                    println!("Error while parsing PID");
+                    process::exit(1);
+                }
+            }
+        }
+
+        _ => {
+            println!("Correct usage: no param or param PID");
+            process::exit(1);
+        }
+    }
+}

hw4/task1/src/pstree.rs

@@ -0,0 +1,95 @@
+extern crate libc;
+
+use procinfo::pid;
+use self::libc::pid_t;
+
+/// Datenstruktur für einen Prozess.
+pub struct Process {
+    name: String,
+    pid: pid_t,
+    ppid: pid_t,
+}
+
+impl Process {
+    /// Erstellt eine Prozess-Datenstruktur aus procinfo::Stat.
+    pub fn new(with_pid: pid_t) -> Self {
+        if let Ok(stat) = pid::stat(with_pid) {
+            Process {
+                name: stat.command,
+                pid: stat.pid,
+                ppid: stat.ppid,
+            }
+        } else {
+            panic!("Internal Error: Process not found")
+        }
+    }
+
+    /// Erstellt eine Prozess-Datenstruktur aus procinfo::Stat.
+    pub fn me() -> Self {
+        if let Ok(my_pid) = pid::stat_self() {
+            Process::new(my_pid.pid)
+        } else {
+            panic!("Internal Error: I don't have a PID but I am running.")
+        }
+    }
+
+    /// Prüft ob das Prozess-Struct ein Elternprozess besitzt.
+    pub fn has_parent(&self) -> bool {
+        self.ppid != 0
+    }
+
+    /// Gibt den Elternprozess zurück.
+    pub fn parent(&self) -> Self {
+        Process::new(self.ppid)
+    }
+
+    /// Prüft ob das Prozess-Struct einen (entfernten) Elternprozess mit dem übergebenen pid hat.
+    pub fn has_parent_with_pid(&self, pid: pid_t) -> bool {
+        if self.pid == pid {
+            return true;
+        }
+
+        if self.has_parent() {
+            return self.parent().has_parent_with_pid(pid);
+        }
+
+        false
+    }
+
+    /// Gibt über Rekursion über die Eltern eine Prozesskette aus.
+    pub fn print_recursive(&self, to_pid: pid_t, output: &mut String) {
+
+        if output.len() == 0 {
+            *output = format!("{}({}){}", self.name, self.pid, output);
+        } else {
+            *output = format!("{}({})---{}", self.name, self.pid, output);
+        }
+
+        if self.has_parent() && self.pid != to_pid {
+            self.parent().print_recursive(to_pid, output);
+        }
+    }
+}
+
+/// Geht von eigenem Prozess aus und gibt die Prozesskette bis zum übergebenem PID aus
+/// und fängt mögliche Fehler ab.
+pub fn print(pid: pid_t) -> bool {
+
+    if let Err(_) = pid::stat(pid) {
+        println!("Invalid PID");
+        return false;
+    }
+
+    let my_proc = Process::me();
+
+    if !my_proc.has_parent_with_pid(pid) {
+        println!("This Process has no parent {}", pid);
+        return false;
+    }
+
+    let mut output = String::new();
+    my_proc.print_recursive(pid, &mut output);
+    println!("{}", output);
+
+    true
+}

hw4/task1/src/readproc.rs

@@ -0,0 +1,66 @@
+use procinfo::pid;
+use procinfo::loadavg;
+
+/// Returns the PID and PPID of the current process.
+/// Throws an error if the current process doesn't exist (should never occur).
+pub fn self_pids() -> Result<(i32, i32), &'static str> {
+    match pid::stat_self() {
+        Ok(stat) => Ok((stat.pid, stat.ppid)),
+        Err(_) => Err("PID not alive: PID and PPID not found"),
+    }
+}
+
+/// Returns the command (string) belonging to the given PID.
+/// Throws an error if the given PID doesn't exist.
+pub fn get_pid_command(pid: i32) -> Result<String, &'static str> {
+    match pid::stat(pid) {
+        Ok(stat) => Ok(stat.command),
+        Err(_) => Err("PID not alive: no command name found"),
+    }
+}
+
+/// Returns the last created command (string) of the system.
+/// Throws an error if there is no last Command.
+pub fn get_last_created_command() -> Result<String, &'static str> {
+    match loadavg() {
+        Ok(stat) => {
+            let last_pid = stat.last_created_pid;
+            match pid::stat(last_pid) {
+                Ok(st) => Ok(st.command),
+                Err(_) => Err("No last command via PID found"),
+            }
+        }
+        Err(_) => Err("No last command found"),
+    }
+}
+
+/// Returns the number of threads belonging to the given PID.
+/// Throws an error if the given PID doesn't exist.
+pub fn get_thread_count(pid: i32) -> Result<u32, &'static str> {
+    match pid::stat(pid) {
+        Ok(stat) => Ok(stat.num_threads as u32),
+        Err(_) => Err("PID not alive: no threads counted"),
+    }
+}
+
+/// Returns the number of total tasks running in the system.
+/// Throws an error if the total number of tasks doesn't exist.
+pub fn get_task_total() -> Result<u32, &'static str> {
+    match loadavg() {
+        Ok(stat) => Ok(stat.tasks_total),
+        Err(_) => Err("No total count of tasks in system found"),
+    }
+}
+
+/// Returns the size of the virtual, code and data memory size of the current process.
+/// Throws an error if the current process doesn't exist (should never occur).
+pub fn get_ownprocess_mem() -> Result<(usize, usize, usize), &'static str> {
+    match pid::stat_self() {
+        Ok(stat) => {
+            let csize = stat.end_code - stat.start_code;
+            let dsize = stat.end_data - stat.start_data;
+            Ok((stat.vsize, csize, dsize))
+        }
+        Err(_) => Err("PID not alive: no memory found"),
+    }
+}

hw4/task1/src/unit_test_pstree.rs

@@ -0,0 +1,57 @@
+#[cfg(test)]
+mod tests {
+    use pstree::Process;
+    use pstree::print;
+
+    #[test]
+    #[should_panic]
+    fn new_invalid_pid() {
+        Process::new(-1000);
+    }
+
+    #[test]
+    fn new_valid_pid() {
+        Process::new(1);
+    }
+
+    #[test]
+    fn hasparent_no() {
+        assert_eq!(false, Process::has_parent(&Process::new(1)));
+    }
+
+    #[test]
+    fn hasparent_yes() {
+        assert_eq!(true, Process::has_parent(&Process::me()));
+    }
+
+    #[test]
+    #[should_panic]
+    fn parent_not_existing() {
+        Process::parent(&Process::new(1));
+    }
+
+    #[test]
+    fn parent_existing() {
+        Process::parent(&Process::me());
+    }
+
+    #[test]
+    fn hasparent_with_pid_not_existing() {
+        assert_eq!(false, Process::has_parent_with_pid(&Process::me(), -1000));
+    }
+
+    #[test]
+    fn hasparent_with_pid_existing() {
+        assert_eq!(true, Process::me().has_parent_with_pid(1));
+    }
+
+    #[test]
+    fn print_not_existing() {
+        assert_eq!(false, print(-1000));
+    }
+
+    #[test]
+    fn print_existing() {
+        assert_eq!(true, print(1));
+    }
+}

hw4/task1/src/unit_test_readproc.rs

@@ -0,0 +1,63 @@
+#[cfg(test)]
+mod tests {
+    use procinfo::pid::{status, status_self};
+    use readproc::{get_ownprocess_mem, get_pid_command, get_task_total, get_thread_count,
+                   self_pids};
+
+    fn sol_self_pids() -> (i32, i32) {
+        match status_self() {
+            Ok(status) => (status.pid, status.ppid),
+            Err(_) => panic!(),
+        }
+    }
+
+    fn name_of_init() -> String {
+        status(1).unwrap().command
+    }
+
+    #[test]
+    fn test_name_of_init() {
+        let status = status(1).unwrap();
+        assert_eq!(name_of_init(), status.command);
+    }
+
+    #[test]
+    fn test0_ppid() {
+        assert_eq!(sol_self_pids(), self_pids().unwrap());
+    }
+
+    #[test]
+    fn test1_command() {
+        assert_eq!(
+            Err("PID not alive: no command name found"),
+            get_pid_command(0)
+        );
+    }
+
+    #[test]
+    fn test2_command() {
+        assert_eq!(Ok(name_of_init()), get_pid_command(1));
+    }
+
+
+    #[test]
+    fn test3_systemd_threads() {
+        let status = status(1).unwrap();
+        assert_eq!(get_thread_count(1), Ok(status.threads));
+    }
+
+    // Only check if fn is defined
+
+    #[test]
+    #[should_panic]
+    fn test8_mem() {
+        assert_eq!(Ok((0, 0, 0)), get_ownprocess_mem());
+    }
+
+    #[test]
+    #[should_panic]
+    fn test9_get_task_total() {
+        assert_eq!(Ok((0)), get_task_total());
+    }
+
+}

hw4/task1/tests/output.bats

@@ -0,0 +1,45 @@
+#!/usr/bin/env bats
+
+
+@test "task1: Check that we have a debug output" {
+    run stat "$BATS_TEST_DIRNAME/../target/debug/task1"
+    [ "$status" -eq 0 ]
+}
+
+
+# wc output with white spaces is trimmed by xargs
+@test "task1: Output with no param must be exact 5 line long" {
+    run bash -c "'$BATS_TEST_DIRNAME/../target/debug/task1'  | wc -l | xargs"
+    [ "$output" = "5" ]
+}
+
+# wc output with white spaces is trimmed by xargs
+@test "task1: Output with to many paras must be exact 1 line long" {
+    run bash -c "'$BATS_TEST_DIRNAME/../target/debug/task1' 2 3 | wc -l | xargs"
+    [ "$output" = "1" ]
+
+}
+
+
+# wc output with white spaces is trimmed by xargs
+@test "task1: Output with wrong para must be exact 1 line long" {
+    run bash -c "'$BATS_TEST_DIRNAME/../target/debug/task1' b | wc -l | xargs"
+    [ "$output" = "1" ]
+}
+
+
+
+@test "task1: Output with wrong PID does not crash" {
+    run bash -c "'$BATS_TEST_DIRNAME/../target/debug/task1' 2 "
+    [ "$status" = 1 ]
+}
+
+@test "task1: Output with wrong PARAM does not crash" {
+    run bash -c "'$BATS_TEST_DIRNAME/../target/debug/task1' a "
+    [ "$status" = 1 ]
+}
+
+@test "task1: Output with to many para does not crash" {
+    run bash -c "'$BATS_TEST_DIRNAME/../target/debug/task1' 2 3 "
+    [ "$status" = 1 ]
+}

hw5/README.md

@@ -0,0 +1,30 @@
+# hw5
+
+## Tasks
+
+To fulfill **hw5** you have to solve:
+
+- task1
+- simu1
+- simu2
+
+## Files
+
+You find already or reuse some files for rust tasks. Please remember to use
+cargo to create the relevant projects for each task.
+
+## Pull-Reuest
+
+Please merge any accepted reviews into your branch. If you are ready with the
+homework, all tests run, please create a pull request named **hw5**.
+
+## Credits for hw5
+
+| Task     | max. Credits | Comment |
+| -------- | ------------ | ------- |
+| task1    | 2            |         |
+| task2    | +1           |         |
+| simu1    | 1            |         |
+| simu2    | 1            |         |
+| Deadline | +1           |         |
+| =        | 6            |         |