Init hw4

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 +1P):
+
+- 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,197 @@
+# Homework hw4 task1
+
+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
+
+## Gliederung
+
+<!-- MarkdownTOC -->
+
+- [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)
+
+<!-- /MarkdownTOC -->
+
+
+## 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.
+
+2. 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.
+
+3. 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.
+
+4. 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.
+
+5. 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!
+
+6. 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.
+
+7. 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?
+
+8. 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.
+
+9. 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** 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 -p -s PID** die Kette aller Elternprozesse dieser PID anzeigen lassen.
+
+   ```text
+   systemd(1)---sshd(1264)---sshd(7161)---sshd(7198)---zsh(7199)---pstree(47200)
+   ```
+
+   Genau diese Ausgabe soll nun ihr Programm erzeugen bei der Option '1'. Geben Sie im obigen Beispiel die PID 7161 als Parameter an, so wird nur der Teil-Tree ausgegeben, startend vom Prozess mit PID 7161.
+
+   ```text
+   sshd(7161)---sshd(7198)---zsh(7199)---pstree(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.
+
+2. 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!
+
+3. 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 dieses Format haben:
+
+    ```text
+    systemd(1)---sshd(1264)---sshd(7161)---sshd(7198)---zsh(7199)---cargo(47150)---task2(47151)
+    ```
+   > Je nachdem wie Sie Ihr Programm aufrufen wird es natürlich andere Ausgaben produzieren. Durch das Kommandozeilen-Tool **pstree** können Sie Ihre Ausgabe kontrollieren!
+
+4. 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.
+
+5. 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 HW (Homework) 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/0.3.1/procinfo/
+[io::Result]: https://doc.rust-lang.org/std/io/type.Result.html

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

@@ -0,0 +1,57 @@
+#[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());
+    }
+
+}