Update master from bsys-ws17-template/hw4

.travis.yml

@@ -1,6 +1,10 @@
 language: rust
 rust: stable
 cache: cargo
+before_install:
+  - sudo add-apt-repository -y ppa:duggan/bats
+  - sudo apt-get update
+  - sudo apt-get -y install bats
 before_script: (cargo install rustfmt || true)
 sudo: false
 git:

ci/run-travis.sh

@@ -14,6 +14,9 @@ MY_PATH="$(dirname "$0")"
 # check that everything compiles and all tests pass
 "$MY_PATH/test-rust.sh"
 
+# after compiles run bats tests
+"$MY_PATH/test-bats.sh"
+
 # file existence
 echo "=== Checking for Missing Files ======================================="
 "$MY_PATH/check-files.py" || true

ci/test-bats.sh

@@ -5,7 +5,7 @@
 # Exit script on the first error
 set -o errexit -o nounset
 
-current_hw=$(find . -type d -name 'hw*' | sort | tail -n1)
+current_hw=$(find . -type f | grep "hw./task./Cargo\.toml" | sort | tail -n1 | cut -d / -f -2)
 
 while IFS= read -r -d '' taskdir; do
 

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
+

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/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/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/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/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/unit_test_readproc.rs

@@ -0,0 +1,59 @@
+#[cfg(test)]
+mod tests {
+    use procinfo::pid::{status, status_self};
+    use {self_pids, get_pid_command, get_thread_count, get_ownprocess_mem, get_task_total};
+
+
+    fn sol_self_pids() -> (i32, i32) {
+        match status_self() {
+            Ok(status) => (status.pid, status.ppid),
+            Err(_) => panic!(),
+        }
+    }
+
+    #[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("systemd".to_string()), get_pid_command(1));
+    }
+
+
+    #[test]
+    fn test3_systemd_command() {
+        let status = status(1).unwrap();
+        assert_eq!("systemd".to_string(), status.command);
+    }
+
+    #[test]
+    fn test4_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 ]
+}

hw4/task2/README.md

@@ -0,0 +1,376 @@
+# Homework hw4 task2
+
+Die folgenden Informationen sollen helfen, sich schneller in die Materie des
+'Timings' von Programmen einzuarbeiten:
+
+- Das externe Crate [time][] bietet mehr und vor allem einfachere Funktionalität
+  als die Rust Standard-Bibliothek.
+- Alle Betriebssysteme stellen eine Time API zu Verfügung. Es kann hilfreich
+  sein zu verstehen, wie diese funktioniert. Daher beschäftigt sich das nächste
+  Kapitel ausführlich mit dieser API.
+- Das Modul [std::mem] aus der Standardbibliothek ist zur Lösung dieser Aufgabe
+  sehr hilfreich.
+
+[time]: https://docs.rs/time
+[std::mem]: https://doc.rust-lang.org/std/mem/
+
+## Warmup für das Programm
+
+Um mit hoher Wahrscheinlichkeit Instruktionen und Daten aus dem Cache zu beziehen, sollte Ihr Programm ein kleines 'Cache' Warmup durchlaufen.
+
+Dies kann über ein simples Inkrementieren erreicht werden. Bei der Berechnung müssen Sie aber darauf achten, dass der Compiler das Ergebnis nicht vorausberechnen kann. Sonst würde bei der Optimierung der Compiler einfach das Ergebnis ausrechnen und das Ergebnis direkt in den Code schreiben. Damit wäre das Warmup (Durchlaufen des Codes) dahin.
+
+Mit einer Parameterübergabe durch die Kommandozeile steht das Ergebnis zur Compile-Zeit nicht fest und somit kann der Code nicht einfach 'weg'-optimiert werden. Dazu ein Beispiel:
+
+```Rust
+//where page_count and jump are cmd arguments
+let mut a = vec![0i32; page_count * jump];
+
+    // warm up
+    for i in a.iter_mut() {
+        *i += 1;
+    }
+```
+
+## Zeiten lesen in C
+
+Das folgende Kapitel muss zur Lösung von task2 nicht komplett verstanden werden.
+Vielmehr soll es weitere Informationen liefern, wenn Ihnen gewisse
+Funktionalitäten der Thematik 'Timing' unklar sind.
+
+- [Datenstrukturen](#datenstrukturen)
+- [Zeit lesen](#zeit-lesen)
+- [Zeitvergleich: Differenzzeitmessung](#zeitvergleich-differenzzeitmessung)
+
+### Datenstrukturen
+
+Betriebssysteme stellen Anwendungen Zeitgeber mit unterschiedlichen
+Eigenschaften zur Verfügung, über die das Zeitverhalten kontrolliert wird. Diese
+sind gekennzeichnet durch ihre
+
+- Genauigkeit,
+- die Zuverlässigkeit,
+- den Bezugspunkt,
+- die Darstellung und
+- den maximalen Zeitbereich.
+
+Das Betriebssystem repräsentiert Zeiten unter anderem mit den folgenden
+Datentypen (Darstellung):
+
+- clock_t: Timerticks.
+- struct timeval: Zeit in Mikrosekunden-Auflösung.
+- struct timespec: Zeit in Nanosekunden-Auflösung.
+- struct tm: absolute Zeitangabe.
+
+```c
+struct timeval {
+
+    time_t      tv_sec;     /* seconds */
+    suseconds_t tv_usec;    /* microseconds */
+};
+
+struct timespec {
+    time_t tv_sec; /* seconds */
+    long tv_nsec; /* nanoseconds */
+};
+
+struct tm
+{
+    int tm_sec; /* seconds */
+    int tm_min; /* minutes */
+    int tm_hour; /* hours */
+    int tm_mday; /* day of the month */
+    int tm_mon; /* month */
+    int tm_year; /* year */
+    int tm_wday; /* day of the week */
+    int tm_yday; /* day in the year */
+    int tm_isdst; /* daylight saving time */
+};
+```
+
+Die Strukturen struct timeval und struct timespec bestehen aus jeweils zwei
+Variablen, die einmal den Sekundenanteil und einmal den Mikro- beziehungsweise
+den Nanosekundenanteil repräsentieren. Die Darstellung erfolgt jeweils normiert.
+Das bedeutet, dass der Mikro- oder Nanosekundenanteil immer kleiner als eine
+volle Sekunde bleibt. Ein Zeitstempel von beispielsweise 1 Sekunde, 123456
+Mikrosekunden ist gültig, 1 Sekunde, 1234567 Mikrosekunden ist ungültig. In
+normierter Darstellung ergäbe sich 2 Sekunden, 234567 Mikrosekunden.
+
+Die Darstellungs- beziehungsweise Repräsentationsform reflektiert auch den
+darstellbaren Wertebereich. Da bei den dargestellten Datenstrukturen für den Typ
+time\_t ein long eingesetzt wird, lassen sich auf einer 32-Bit Maschine rund 4
+Milliarden Sekunden zählen, auf einer 64-Bit Maschine 2\^64 (mehr als 500
+Milliarden Jahre).
+
+Als Bezugspunkte haben sich die folgenden eingebürgert: *Start des Systems,
+*Start eines Jobs und \*Start einer Epoche, beispielsweise "Christi Geburt" oder
+der 1.1.1970 (Unix-Epoche). Dieser Bezugspunkt weist zudem noch eine örtliche
+Komponente auf: Der Zeitpunkt 19:00 Uhr in Europa entspricht beispielsweise
+einem anderen Zeitpunkt in den USA (minus sechs Stunden zur Ostküste).
+
+Die Genauigkeit wird beeinflußt durch, die Taktung des Zeitgebers, deren
+Schwankungen und durch Zeitsprünge.
+
+Das Attribut Zuverlässigkeit eines Zeitgebers beschreibt dessen Verhalten bei
+(bewußten) Schwankungen der Taktung und bei Zeitsprüngen: Ein Zeitgeber kann
+beispielsweise der Systemuhr folgen (CLOCK\_REALTIME) oder unabhängig von
+jeglicher Modifikation an der Systemzeit einfach weiterzählen
+(CLOCK\_MONOTONIC). Die Posix-Realzeiterweiterung beziehungsweise Linux-Systeme
+definieren hierzu folgende Clocks [Man-Page zu
+clock\_gettime()](http://linux.die.net/man/3/clock_gettime):
+
+- **CLOCK\_REALTIME**: Dieser Zeitgeber repräsentiert die systemweite, aktuelle
+  Zeit. Er reagiert auf Zeitsprünge, sowohl vorwärts als auch rückwärts, die
+  beispielsweise beim Aufwachen (Resume) nach einem Suspend (Schlafzustand des
+  gesamten Systems) ausgelöst werden. Er reagiert ebenfalls auf unterschiedliche
+  Taktungen, die beispielsweise durch NTP erfolgen. Dieser Zeitgeber liefert die
+  Sekunden und Nanosekunden seit dem 1.1. 1970 UTC (Unixzeit) zurück.
+- **CLOCK\_MONOTONIC**: Dieser Zeitgeber läuft entsprechend seiner Auflösung
+  stets vorwärts, ohne dabei Zeitsprünge zu vollziehen. Er ist also unabhängig
+  von der mit Superuserprivilegien zu verändernden Systemuhr. Allerdings
+  reagiert dieser Zeitgeber auf Modifikationen der Taktung, die beispielsweise
+  durch NTP erfolgen.
+- **CLOCK\_MONOTONIC_RAW**: Dieser Zeitgeber ist linuxspezifisch. Er reagiert
+  weder auf Zeitsprünge noch auf in Betrieb geänderte Taktungen (NTP).
+- **CLOCK\_PROCESS\_CPUTIME_ID**: Dieser Zeitgeber erfasst die Verarbeitungszeit
+  (Execution Time) des zugehörigen Prozesses. Das funktioniert aber nur
+  zuverlässig auf Single-Core-Systemen beziehungsweise wenn sichergestellt
+  werden kann, dass keine Prozessmigration stattfindet.
+- **CLOCK\_THREAD\_CPUTIME\_ID**: Dieser Zeitgeber erfasst die Verarbeitungszeit
+  (Execution Time) des zugehörigen Threads. Das funktioniert aber nur
+  zuverlässig auf Single-Core-Systemen beziehungsweise wenn sichergestellt
+  werden kann, dass keine Prozessmigration stattfindet.
+
+Der maximale Zeitbereich schließlich ergibt sich durch die Auflösung des
+Zeitgebers und die Bitbreite der Variablen:
+
+```text
+zeitbereich = auflösung * 2^bitbreite
+```
+
+### Zeit lesen
+
+Es gibt unterschiedliche Systemfunktionen, mit denen die aktuelle Zeit gelesen
+werden kann. Favorisiert ist die Funktion *int clock\_gettime(clockid\_t
+clk\_id, struct timespec * tp)*, die die Zeit seit dem 1.1.1970 (Unixzeit) als
+Universal Time (Zeitzone UTC) zurückliefert (struct timespec). Konnte die
+aktuelle Zeit gelesen werden, gibt die Funktion Null, ansonsten einen Fehlercode
+zurück. Allerdings ist das Auslesen auf 32-Bit Systemen in so fern
+problematisch, da der 32-Bit Zähler am 19. Januar 2038 überläuft.
+
+```c
+struct timespec {
+        time_t   tv_sec;        /* seconds */
+        long     tv_nsec;       /* nanoseconds */
+};
+
+```
+
+```c
+struct timespec timestamp;
+    ...
+    if (clock_gettime(CLOCK_MONOTONIC,&timestamp))
+    {
+        perror("timestamp");
+        return -1;
+    }
+    printf("seconds: %ld, nanoseconds: %ld\n",
+        timestamp.tv\_sec, timestamp.tv\_nsec);
+```
+
+Durch die Wahl der Clock CLOCK\_PROCESS\_CPUTIME\_ID beziehungsweise
+CLOCK\_THREAD\_CPUTIME\_ID kann auch die Verarbeitungszeit ausgemessen werden
+(Profiling).
+
+Die Genauigkeit der zurückgelieferten Zeit kann mit Hilfe der Funktion
+*clock\_getres(clockid\_t clk\_id, struct timespec * res)* ausgelesen werden.
+
+Die Funktion *clock\_gettime()* ist nicht in der Standard-C-Bibliothek zu
+finden, sondern in der Realzeit-Bibliothek librt. Daher ist bei der
+Programmgenerierung diese Bibliothek hinzuzulinken (Parameter -lrt). Steht nur
+die Standard-C-Bibliothek zur Verfügung, kann
+
+- time\_t time(time\_t *t) oder auch
+- int gettimeofday(struct timeval * tv, struct timezone * tz)
+
+eingesetzt werden.
+
+*time()* gibt die Sekunden zurück, die seit dem 1.1.1970 (UTC) vergangen sind.
+
+```c
+time_t now;
+...
+now = time(NULL);
+```
+
+*gettimeofday()* schreibt an die per tv übergebene Speicheradresse die Sekunden
+und Mikrosekunden seit dem 1.1.1970. Das Argument tz wird typischerweise mit
+NULL angegeben.
+
+Liegen die Sekunden seit dem 1.1.1970 vor (timestamp.tv\_sec), können diese mit
+Hilfe der Funktionen
+
+- struct tm *localtime\_r(const time\_t *timep, struct tm *result) oder
+- struct tm *gmtime\_r(const time\_t * timep, struct tm *result)
+
+in die Struktur *struct tm* konvertiert werden.
+
+```c
+struct tm absolute_time;
+if (localtime_r( timestamp.tv_sec, &absolute_time )==NULL)
+{
+    perror("localtime_r" );
+    return -1;
+}
+
+printf("year: %d\n", absolute_time.tm_year);
+```
+
+Die Funktion *time\_t mktime(struct tm * tm)* konvertiert eine über die Struktur
+struct tm gegebene Zeit in Sekunden seit dem 1.1.1970 (time\_t).
+
+Mit Hilfe der Funktion *clock\_t times(struct tms \ buf)* lässt sich sowohl die
+aktuelle Zeit zu einem letztlich nicht genau definierten Bezugspunkt, als auch
+die Verarbeitungszeit (Execution-Time) des aufrufenden Prozesses bestimmen. Die
+Zeiten werden als Timerticks (clock\_t) zurückgeliefert. Die zurückgelieferte
+Verarbeitungszeit ist aufgeschlüsselt in die Anteile, die im Userland und die
+Anteile, die im Kernel verbraucht wurden. Außerdem werden diese Anteile auch für
+Kindprozesse gelistet.
+
+```c
+#include <stdio.h>
+#include <sys/times.h>
+#include <unistd.h>
+#include <time.h>
+
+int main( int argc, char **argv, char **envp )
+{
+    struct tms exec_time;
+    clock_t act_time;
+    long ticks_per_second;
+    long tickduration_in_ms;
+
+    ticks_per_second = sysconf(_SC_CLK_TCK);
+    tickduration_in_ms = 1000/ticks_per_second;
+
+    act_time = times( &exec_time );
+    printf("actual time (in ms): %ld\n", act_time*tickduration_in_ms);
+    printf("execution time (in ms): %ld\n",
+            (exec_time.tms_utime+exec_time.tms_stime)*tickduration_in_ms);
+
+    return 0;
+
+}
+```
+
+Sehr genaue Zeiten lassen sich erfassen, falls der eingesetzte Prozessor einen
+Zähler besitzt, der mit der Taktfrequenz des Systems getaktet wird. Bei einer
+x86-Architektur (PC) heißt dieser Zähler Time Stamp Counter (TSC). Der TSC kann
+auch von einer normalen Applikation ausgelesen werden, allerdings muss
+sichergestellt sein, dass sich die Taktfrequenz zwischen zwei Messungen ändert.
+Alternativ kann man sich vom Betriebssystem über die Taktänderung informieren
+lassen.
+
+### Zeitvergleich: Differenzzeitmessung
+
+Zwei Absolutzeiten (struct tm) werden am einfachsten über deren Repräsentation
+in Sekunden verglichen. Die Umwandlung erfolgt über die Funktion (time\_t
+mktime(struct tm \*tm)). Allerdings ist dabei zu beachten, dass es auf einem
+32-Bit System am 19. Januar 2038 zu einem Überlauf kommt. Wird einer der beiden
+Zeitstempel vor dem 19. Januar 2038 genommen, der andere danach, kommt es zu
+einem falschen Ergebnis, wenn nur die beiden Werte per "\<" beziehungsweise "\>"
+verglichen werden.
+
+Das ist ein generelles Problem und kann dann gelöst werden, wenn sichergestellt
+ist, dass die zu vergleichenden Zeiten nicht weiter als die Hälfte des gesamten
+Zeitbereiches auseinanderliegen. In diesem Fall lassen sich die Makros
+einsetzen, die im Linux-Kernel für den Vergleich zweier Zeiten eingesetzt
+werden. Das Makro time\_after(a,b) liefert true zurück, falls es sich bei a um
+eine spätere Zeit als b handelt. Das Makro time\_after\_eq(a,b) liefert true
+zurück, falls es sich bei a um eine spätere Zeit oder um die gleiche Zeit
+handelt, wie b handelt. Die Zeitstempel a und b müssen beide vom Typ unsigned
+long sein. Natürlich können die Makros auch auf andere Datentypen angepasst
+werden
+
+[HEADERDATEI linux/jiffies.h].
+
+```c
+#define time_after(a,b)         \
+        (typecheck(unsigned long, a) && \
+         typecheck(unsigned long, b) && \
+         ((long)(b) - (long)(a) < 0))
+
+#define time_before(a,b)        time_after(b,a)
+
+#define time_after_eq(a,b)      \
+        (typecheck(unsigned long, a) && \
+         typecheck(unsigned long, b) && \
+         ((long)(a) - (long)(b) \>= 0))
+
+#define time_before_eq(a,b)     time_after_eq(b,a)
+```
+
+Beim Benchmarking ist es häufig notwendig eine Zeitdauer zu messen, Zeitpunkte
+zu erfassen oder eine definierte Zeit verstreichen zu lassen. Dabei sind
+folgende Aspekte zu beachten:
+
+- Die Genauigkeit der eingesetzten Zeitgeber,
+- die maximalen Zeitdifferenzen,
+- Schwankungen der Zeitbasis, beispielsweise durch Schlafzustände,
+- Modifikationen an der Zeitbasis des eingesetzten Rechnersystems (Zeitsprünge)
+  und
+- die Ortsabhängigkeit absoluter Zeitpunkte.
+
+Zur Bestimmung einer Zeitdauer verwendet man häufig eine Differenzzeitmessung.
+Dabei wird vor und nach der auszumessenden Aktion jeweils ein Zeitstempel
+genommen. Die Zeitdauer ergibt sich aus der Differenz dieser beiden Zeitstempel.
+
+Dies ist allerdings nicht immer ganz einfach. Liegt der Zeitstempel
+beispielsweise in Form der Datenstruktur struct timeval (als Ergebnis der
+Funktion *gettimeofday()*) vor, müssen die Sekunden zunächst getrennt von den
+Mikrosekunden subtrahiert werden. Ist der Mikrosekundenanteil negativ, muss der
+Sekundenanteil um eins erniedrigt und der Mikrosekundenanteil korrigiert werden.
+Dazu wird auf die Anzahl der Mikrosekunden pro Sekunde (also eine Million) der
+negative Mikrosekundenanteil addiert.
+
+```c
+#define MICROSECONDS\_PER\_SECOND 1000000
+
+struct timespec * diff_time( struct timeval before, struct timeval after,
+    struct timeval *result )
+{
+    if (result==NULL)
+        return NULL;
+
+    result->tv_sec = after.tv_sec - before.tv_sec;
+    result->tv_usec= after.tv_usec- before.tv_usec;
+
+    if (result->tv_usec<0) {
+        result->tv_sec--;
+        /* result->tv_usec is negative, therefore we use "+" */
+        result->tv_usec = MICROSECONDS_PER_SECOND+result->tv_usec;
+    }
+    return result;
+
+}
+```
+
+Für Zeitstempel vom Typ struct timeval gilt entsprechendes. Anstelle der
+MICROSECONDS\_PER\_SECOND sind NANOSECONDS\_PER\_SECOND einzusetzen. Sind die
+Zeitstempel vorzeichenlos, sieht die Rechnung für den Sekundenanteil etwas
+komplizierter aus. Das soll hier aber nicht weiter vertieft werden.
+
+Etwas einfacher ist die Differenzbildung, wenn aus der Datenstruktur eine
+einzelne Variable mit der gewünschten Auflösung, beispielsweise Mikrosekunden,
+generiert wird. Im Fall von struct timeval wird dazu der Sekundenanteil mit
+einer Million multipliziert und der Mikrosekundenanteil aufaddiert. Bei der
+Multiplikation können natürlich Informationen verloren gehen, allerdings geht
+der gleiche Informationsgehalt auch beim zweiten Zeitstempel verloren. Für die
+Differenzbildung ist das damit nicht relevant, solange der zu messende zeitliche
+Abstand kleiner als 1000 Sekunden ist und es während der Messung keinen Überlauf
+beim Sekundenanteil gibt.
+
+```c
+time_in_usec=((nachher.tv_sec*1000000)+nachher.tv_usec)-
+    ((vorher.tv_sec*1000000)+vorher.tv_usec);
+```