Update master from bsys-ws17-template/hw1

files/hw1.txt

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

hw1/README.md

@@ -0,0 +1,47 @@
+# hw1
+
+## Tasks
+To fullfill **hw1** you have to solve:
+
+- task1
+- task2
+- task3
+- task4
+- simu1
+
+Optinal are (bonus +1P):
+
+- task5
+- simu2
+
+## Files
+You find already files for earch rust task.
+
+## ASIDE: SIMULATION HOMEWORKS
+
+Simulation homeworks (`simuN/`) come in the form of simulators you run to
+make sure you understand some piece of the material. The simulators are generally python programs that enable you both to generate different problems (using different random seeds) as well as to have the program solve the problem for you (with the `-c` flag) so that you can check your answers. Running any simulator with a `-h` or `--help`flag will provide with more information as to all the options the simulator gives you.
+
+The README provided with each simulator gives more detail as to how to run it. Each flag is described in some detail therein.
+
+You find all Files for your simulation homework in the `simuN/` directory.
+
+## Pull-Reuest
+
+If you are ready with the homework, all tests run, please create a pull request named **hw1**.
+
+## Gradings
+
+### hw1
+
+| Task | max. Credits | Comment |
+|---|---|---|
+| simu1 | 1 | |
+| task1 | 1 | |
+| task2 | 1 | |
+| task3 | 0,5 | |
+| task4 | 0,5 | |
+| simu2 | +0,5 | |
+| task5 | +0,5 | |
+| Deadline | +1 | |
+| = | 6 | |

hw1/simu1/QUESTIONS.md

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

hw1/simu1/README-process-run.md

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

hw1/simu1/process-run.py

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

hw1/simu2/QUESTIONS.md

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

hw1/task1/README.md

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

hw1/task1/src/lib.rs

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

hw1/task1/tests/task1.rs

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

hw1/task2/README.md

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

hw1/task2/src/lib.rs

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

hw1/task2/tests/task2.rs

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

hw1/task3/README.md

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

hw1/task3/src/lib.rs

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

hw1/task3/tests/task3.rs

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

hw1/task4/README.md

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

hw1/task4/src/lib.rs

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

hw1/task4/tests/task4.rs

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

hw1/task5/README.md

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

hw1/task5/src/main.rs

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

hw1/task5/tests/output.bats

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