thesis: Adapt to feedback from Prof.

.gitignore

@@ -4,3 +4,5 @@ bin/
 *.o
 *.log
 *.pdf
+related-work/
+main

proj/intercept/intercept

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+# File: intercept
+# Author: Lorenz Stechauner <e12119052@student.tuwien.ac.at>
+#         Lorenz Stechauner <lorenz.stechauner@necronda.net>
+
 import argparse
 import subprocess
 import os

proj/intercept/src/intercept.c

@@ -1,4 +1,10 @@
 
+/**
+ * File: intercept.c
+ * Author: Lorenz Stechauner <e12119052@student.tuwien.ac.at>
+ *         Lorenz Stechauner <lorenz.stechauner@necronda.net>
+ */
+
 #define _GNU_SOURCE
 
 #include <getopt.h>
@@ -1226,7 +1232,7 @@ int sym(getopt)(const int argc, char *const argv[], const char *shortopts) {
         else if_invalid(getopt)
     }
     const int ret = __real_getopt(argc, argv, shortopts);
-    msg("return %i", ret);
+    msg("return %i; optind %i", ret, optind);
     return ret;
 }
 
@@ -1240,7 +1246,7 @@ void sym(exit)(int status) {
         char msg_buf[BUFFER_SIZE];
         rcv(msg_buf, sizeof(msg_buf));
         if_modify_int("exit", int, status)
-        else if_invalid(getopt)
+        else if_invalid(exit)
     }
     __real_exit(status);
 }
@@ -1419,7 +1425,7 @@ int sym(sigaction)(int sig, const struct sigaction *restrict act, struct sigacti
             if (sigismember(&act->sa_mask, i) != 1)
                 continue;
             if (maskstr[0] != 0) strcat(maskstr, ",");
-            strcat(maskstr, getsigstr(i));
+            sprintf(maskstr + strlen(maskstr), "%i:%s", i, getsigstr(i));
         }
         if (!verbosity) {
             msg("sigaction(%i:%s, %p:{}, %p)" ret_str, sig, sigstr, act, oact, ret_data);
@@ -1462,7 +1468,7 @@ int sym(sigaction)(int sig, const struct sigaction *restrict act, struct sigacti
             if (sigismember(&oact->sa_mask, i) != 1)
                 continue;
             if (maskstr[0] != 0) strcat(maskstr, ",");
-            strcat(maskstr, getsigstr(i));
+            sprintf(maskstr + strlen(maskstr), "%i:%s", i, getsigstr(i));
         }
         msg("return %i; errno %s; oact={sa_flags: 0x%x:%s, %s: %p, sa_mask: [%s]}", ret, strerrorname_np(errno), oact->sa_flags, flgstr, name, ptr, maskstr);
     } else {

proj/perf/Makefile

@@ -0,0 +1,16 @@
+
+CC=gcc
+CFLAGS=-std=c99 -pedantic -Wall -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_SVID_SOURCE -D_POSIX_C_SOURCE=200809L -g
+
+.PHONY: all clean
+all: default
+default: main
+
+main.o: main.c
+	$(CC) -c -o $@ $^ $(CFLAGS)
+
+main: main.o
+	$(CC) -o $@ $^ $(CFLAGS) -lc
+
+clean:
+	rm -rf main *.o

proj/perf/main.c

@@ -0,0 +1,33 @@
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+int main(const int argc, const char *argv[]) {
+    if (argc != 2) {
+        fprintf(stderr, "usage: main <cycles>\n");
+        return 1;
+    }
+
+    const long cycles = strtol(argv[1], NULL, 10);
+
+    struct timespec start, end;
+    clock_gettime(CLOCK_MONOTONIC, &start);
+
+    int pipes[2];
+    for (int i = 0; i < cycles; i++) {
+        if (pipe(pipes) != 0) {
+            fprintf(stderr, "unable to create pipes: %s\n", strerror(errno));
+            exit(1);
+        }
+        close(pipes[0]);
+        close(pipes[1]);
+    }
+
+    clock_gettime(CLOCK_MONOTONIC, &end);
+    const long duration = end.tv_sec * 1000000000 + end.tv_nsec - start.tv_sec * 1000000000 - start.tv_nsec;
+    printf("start: %li.%09li\nend:   %li.%09li\nduration: %li,%03li,%03li ns\n", start.tv_sec, start.tv_nsec, end.tv_sec, end.tv_nsec, duration / 1000000, duration / 1000 % 1000, duration % 1000);
+}

proj/perf/test.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+REPEAT=30
+CYCLES=50
+
+function test() {
+  echo $@
+  for c in $(seq 1 $CYCLES); do
+    for i in $(seq 1 $REPEAT); do
+      echo "cycles: $((c * 100)) ($i/$REPEAT)"
+      $@ $((c * 100))
+      sleep 1
+    done
+  done
+}
+
+test ./main
+cd ../intercept
+test ./intercept -o -i - -- ../perf/main
+test ./intercept -o -i stderr -- ../perf/main
+test ./intercept -o -i file:out.log -- ../perf/main
+#test ./intercept -o -i unix:/ -- ../perf/main

proj/server/src/intercept/__init__.py

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+# File: intercept/__init__.py
+# Author: Lorenz Stechauner <e12119052@student.tuwien.ac.at>
+#         Lorenz Stechauner <lorenz.stechauner@necronda.net>
+
 from __future__ import annotations
 from typing import Optional, TypedDict, NamedTuple, NotRequired, BinaryIO
 from socketserver import UnixStreamServer, StreamRequestHandler, ThreadingMixIn
@@ -23,7 +27,7 @@ class Flags(NamedTuple):
     flags: list[str]
 
 StructTimeSpec = TypedDict('StructTimeSpec', {'tv_sec': int, 'tv_nsec': int})
-StructSigAction = TypedDict('StructSigAction', {'sa_flags': Flags, 'sa_handler': NotRequired[Pointer], 'sa_sigaction': NotRequired[Pointer], 'sa_mask': list[str]})
+StructSigAction = TypedDict('StructSigAction', {'sa_flags': Flags, 'sa_handler': NotRequired[Pointer], 'sa_sigaction': NotRequired[Pointer], 'sa_mask': list[Constant]})
 StructSockAddr = TypedDict('StructSockAddr', {'sa_family': Constant, 'sa_data': NotRequired[bytes],
                                               'sun_path': NotRequired[bytes],
                                               'sin_addr': NotRequired[bytes], 'sin_port': NotRequired[int],
@@ -263,7 +267,7 @@ class Parser:
                     idx += 1
                 value = int(value, 0) if value != '(nil)' else 0
                 return PointerTo(val, value), idx
-            m = re.match(r'[A-Z0-9_]+', argument[idx:])
+            m = re.match(r'[A-Z0-9_]+|\?', argument[idx:])
             if m is not None:
                 value = m.group(0)
                 idx += len(value)
@@ -302,6 +306,8 @@ class Parser:
         self.pid, self.tid = int(pid), int(tid)
         if len(self.stack) == 0:
             self.stack[(self.pid, self.tid)] = []
+        elif (self.pid, self.tid) not in self.stack:
+            self.stack[(self.pid, self.tid)] = []
         if not data.startswith(b'return ') and not data == b'return':
             call = data.decode('utf-8')
             #print(f'[{self.pid}][{self.tid}] {call}')
@@ -344,6 +350,10 @@ class Parser:
             other_vals = ret[1].strip() if len(ret) > 1 else ''
             ret_value, _ = Parser.parse_arg(ret[0][7:])
             kwargs = {}
+            if other_vals.startswith('optind '):
+                ret = other_vals[7:].split(';', 1)
+                kwargs['optind'] = int(ret[0].strip())
+                other_vals = ret[1].strip() if len(ret) > 1 else ''
             if other_vals.startswith('errno '):
                 ret = other_vals[6:].split(';', 1)
                 kwargs['errno'] = ret[0].strip()
@@ -404,7 +414,7 @@ class Parser:
     def before_getopt(self, argc: int, argv: PointerTo[list[PointerTo[bytes]]], optstring: PointerTo[bytes]) -> str:
         raise NotImplementedError()
     def after_getopt(self, argc: int, argv: PointerTo[list[PointerTo[bytes]]], optstring: PointerTo[bytes],
-                     ret_value: int) -> None:
+                     ret_value: int, optind: int = None) -> None:
         raise NotImplementedError()
     def before_exit(self, status: int) -> str:
         raise NotImplementedError()

proj/server/src/intercept/standard.py

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+# File: intercept/standard.py
+# Author: Lorenz Stechauner <e12119052@student.tuwien.ac.at>
+#         Lorenz Stechauner <lorenz.stechauner@necronda.net>
+
 from __future__ import annotations
 from intercept import *
 

proj/server/src/test-interrupts

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+# File: test-interrupts
+# Author: Lorenz Stechauner <e12119052@student.tuwien.ac.at>
+#         Lorenz Stechauner <lorenz.stechauner@necronda.net>
+
 import os
 import sys
 import argparse

proj/server/src/test-memory

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+# File: test-memory
+# Author: Lorenz Stechauner <e12119052@student.tuwien.ac.at>
+#         Lorenz Stechauner <lorenz.stechauner@necronda.net>
+
 import argparse
 import subprocess
 import os

proj/server/src/test-return-values

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+# File: test-return-values
+# Author: Lorenz Stechauner <e12119052@student.tuwien.ac.at>
+#         Lorenz Stechauner <lorenz.stechauner@necronda.net>
+
 import os
 import sys
 import argparse
@@ -102,7 +106,7 @@ def main() -> None:
                 entry[ret] = set()
             entry[ret].add(tuple(c for c in iter_tree_ok(child)))
 
-    allowed_cleanup_functions = ['malloc', 'free', 'freeaddrinfo', 'close', 'exit']
+    allowed_cleanup_functions = ['malloc', 'free', 'freeaddrinfo', 'close', 'exit', 'sigaction']
     for call, errors in calls.items():
         if len(errors) <= 1:
             continue

thesis/.gitignore

@@ -2,6 +2,7 @@
 /intro.*
 /example.*
 /*.pdf
+!/*v*.pdf
 /*.txt
 /_minted/
 *.acn

thesis/src/00.abstract.tex

@@ -1,3 +1,9 @@
 % Abstract
 
-Lorem Ipsum.
+This thesis presents methods for intercepting and manipulating function calls in Linux systems, with a focus on supporting automated testing of student programs in the Operating Systems course.
+The central contribution is the development of \texttt{intercept.so}, a shared object preloaded via the \texttt{LD\_PRELOAD} mechanism, which enables function call interception at runtime without requiring modifications to the program or its source code.
+The library records detailed information about function calls, including arguments, return values, and call locations, allowing precise reconstruction and analysis of program execution.
+Furthermore, it introduces controlled manipulation of intercepted calls---modifying arguments, forcing failures, or mocking return values---through a simple communication protocol, enabling robust automated tests of error handling and resource management.
+Performance evaluations show minimal overhead in practical scenarios, making the approach suitable for educational use.
+Compared to existing tools such as \texttt{strace} or \texttt{ltrace}, this solution offers greater flexibility by combining interception with manipulation capabilities.
+Overall, the approach provides a flexible and transparent foundation for automated testing of low-level C programs, improving reliability while imposing negligible runtime overhead.

thesis/src/00.kurzfassung.tex

@@ -1,3 +1,10 @@
 % Kurzfassung
 
-Lorem Ipsum.
+Diese Arbeit stellt Methoden zum Abfangen und Manipulieren von Funktionsaufrufen in Linux-Systemen vor, mit dem Schwerpunkt auf der Unterstützung automatisierter Tests von Studierendenprogrammen im Rahmen der Betriebssysteme-Lehrveranstaltung.
+Der zentrale Beitrag ist die Entwicklung von \texttt{intercept.so}, einer Shared Object-Bibliothek, die über den Mechanismus \texttt{LD\_PRELOAD} eingebunden wird und so das Abfangen von Funktionsaufrufen zur Laufzeit ermöglicht, ohne dass Änderungen am Programm oder dessen Quellcode erforderlich sind.
+Die Bibliothek protokolliert detaillierte Informationen über Funktionsaufrufe, einschließlich Argumenten, Rückgabewerten und Aufrufstellen, wodurch eine präzise Rekonstruktion und Analyse der Programmausführung möglich wird.
+Darüber hinaus erlaubt sie die kontrollierte Manipulation abgefangener Aufrufe -- etwa durch das Ändern von Argumenten, das Erzwingen von Fehlern oder das Simulieren von Rückgabewerten -- mittels eines einfachen Kommunikationsprotokolls.
+Dies ermöglicht robuste automatisierte Tests zur Überprüfung von Fehlerbehandlung und Ressourcenverwaltung.
+Leistungsmessungen zeigen, dass der Ansatz in praktischen Szenarien nur minimale Laufzeitkosten verursacht und sich somit gut für den Einsatz in der Lehre eignet.
+Im Vergleich zu bestehenden Werkzeugen wie \texttt{strace} oder \texttt{ltrace} bietet die Lösung eine größere Flexibilität, da sie das Abfangen mit Manipulationsmöglichkeiten kombiniert.
+Insgesamt stellt der Ansatz eine flexible und transparente Grundlage für automatisierte Tests von Low-Level-C-Programmen dar, verbessert deren Zuverlässigkeit und verursacht dabei nur vernachlässigbaren Laufzeit-Overhead.

thesis/src/01.introduction.tex

@@ -1,20 +1,56 @@
 
 \chapter{Introduction}\label{ch:introduction}
 
-Lorem Ipsum.
+Intercepting (also known as Hooking, or Tracing) system or function calls allows one to trace what a given program does.
+This information is useful for security analysis or when testing or verifying a program.
+This chapter gives a general overview about what the motivation and goal for this work were (Section~\ref{sec:motivation-and-goal}), and what the difference between system calls and function calls is (Section~\ref{sec:definitions}).
 
-\section{TODO: Why intercept?}
 
-Lorem Ipsum.
+\section{Motivation and Goal}\label{sec:motivation-and-goal}
 
-\section{TODO: Why are current solutions not enough?}
+When teaching students about Operating Systems, their interfaces, and standard libraries, C is still a widely used language, especially when using Linux.
+Therefore, it is obvious why many university courses still require students to write their assignments and exams in C\@.
+The problem when trying to verify whether students have correctly implemented their assignment, is that low-level OS constructs (like semaphores, pipes, sockets, memory management) make it hard to run automated tests, because the testing system needs to keep track, set up, and verify the usage of these resources.
 
-Lorem Ipsum.
+The goal of this work was to find a way to easily intercept system or function calls, and to verify if students called the right functions, with the right arguments, at the right time.
+This restriction in scope allows focusing on simple binary programs without having to think about complex or I/O heavy programs.
+Furthermore, in this setting the source code of the student's programs is obviously available, because this is what they need to deliver.
+The availability of source code is a key concern when trying to intercept function or system calls, as will be clear in the next chapters.
 
-\section{TODO: Linux/C/ELF call structure}
 
-Lorem Ipsum.
+\section{Definitions}\label{sec:definitions}
 
-\section{TODO: System Calls vs. Function Calls}\label{sec:system-calls-vs-function-calls}
+First, function calls, system calls, and their differences need to be defined.
+The following subsections concern these definitions.
 
-Lorem Ipsum.
+
+\subsection{Function Calls}\label{subsec:function-calls}
+
+Generally, a function in C (and also most other programming languages) is a piece of code that may be called, and therefore executed, from elsewhere.
+Functions have zero or more arguments and return a single value.
+When calling a function, the caller places the return address onto the stack.
+This address indicates where the function should continue executing when it is finished.
+
+Functions are used to structure programs, reuse functionality, or expose functionality in libraries.
+Other languages than C differentiate between functions, methods, procedures, and so on.
+A function written in the source code is almost always compiled to a function in the resulting binary.
+
+Intercepting calls to functions allows one to see the function name, arguments, return value, and return address.
+
+
+\subsection{System Calls}\label{subsec:system-calls}
+
+In contrast to functions, system calls are calls to the kernel itself.
+Many operations on a modern operating system require special privileges, which a simple user-space process does not have.
+By invoking a system call, the (user-space) process hands control over to the (privileged) kernel, and requests an operation to be performed.
+\cite[Chapter~10]{linuxkernel}
+
+How exactly these system calls work depends on the architecture and operating system.
+But generally, the process places the system call number and its arguments in defined registers and then executes a special system call opcode.
+Then the kernel executes the requested operation and places the return value inside another register, and lastly hands the execution back to the process.
+\cite[Chapter~10]{linuxkernel}
+
+Intercepting system calls allows one to see the system call number, arguments, and return value.
+One has to keep in mind, that many system-related functionalities are not, in fact, translated to system calls one-to-one.
+For example, \texttt{malloc}~\cite{malloc.3} has no dedicated system call, it is managed by the C standard library internally.
+Many system calls have corresponding wrapper functions in the C standard library (like \texttt{open}, \texttt{close}, \texttt{sem\_wait}).

thesis/src/02.intercept.tex

@@ -1,18 +1,17 @@
 
 \chapter{Intercepting Function Calls}\label{ch:intercepting-function-calls}
 
-In this chapter all steps on how to intercept function calls in this work are discussed.
+In this chapter, all steps on how to intercept function calls in this work are discussed.
 An example of what the resulting interception looks like may be found in Section~\ref{sec:intercepting-example}.
 Furthermore, an overview on how to test given programs is presented in Section~\ref{sec:automated-testing-on-intercepted-function-calls}.
-This chapter does not discuss how these function calls may be manipulated in any way.
-For that see Chapter~\ref{ch:manipulating-function-calls}.
+How these function calls may be manipulated is discussed in Chapter~\ref{ch:manipulating-function-calls}.
 
 
 \section{Identified Methods for Intercepting Function and System Calls}\label{sec:methods-for-intercepting}
 
 First, one has to answer the question on \textit{how exactly} to intercept function or system calls.
-At the beginning of this work it was not yet determined if the interception of function calls, system calls, or both should be used to achieve the overarching goal (see\todo{Goals}).
-This first section tries to list all possible methods on how to intercept function or system calls but does not claim completeness.
+At the beginning of this work, it was not yet determined if the interception of function calls, system calls, or both should be used to achieve the overarching goal (see Section~\ref{sec:motivation-and-goal}).
+This first section tries to list all possible and relevant methods on how to intercept function or system calls but does not claim exhaustiveness.
 The order of the following subsections is roughly based on the thought process on finding the most appropriate method suitable for this work.
 
 
@@ -57,8 +56,7 @@ exit_group(0)                           = ?
   \label{lst:strace}
 \end{listing}
 
-This approach works great for debugging and other use-cases,
-but only intercepting system calls does not statisfy the requirements for this work.
+This approach works well for debugging and other use cases, but intercepting system calls alone does not satisfy the requirements of this work.
 
 
 \subsection{\texttt{ltrace} Command}\label{subsec:ltrace}
@@ -68,7 +66,7 @@ It works similarly to \texttt{strace} (see \ref{subsec:strace}).
 \cite{ltrace.1}
 
 Listings~\ref{lst:main.c} and~\ref{lst:ltrace} illustrate what the output of \texttt{ltrace} looks like.
-In contrast to the output of \texttt{strace} now only ``real'' calls to library functions are included in the output.
+In contrast to the output of \texttt{strace}, now only ``real'' calls to library functions are included in the output.
 Therefore, a lot less ``noise'' is generated (see omitted lines in Listing~\ref{lst:strace}).
 Again, the function arguments are displayed in a ``pretty'' way.
 This command uses so-called prototype functions~\cite{ltrace.conf.5} to format function arguments.
@@ -135,7 +133,7 @@ See the gcc(1) Linux manual page~\cite[Section OPTIONS]{gcc.1}:
 This means, by specifying \texttt{-Wl,-{}-wrap=\textit{symbol}} when compiling using gcc,
 all calls from the currently compiled program to \texttt{\textit{symbol}} are redirected to \texttt{\_\_wrap\_\textit{symbol}}.
 To call the real function inside the wrapper, \texttt{\_\_real\_\textit{symbol}} may be used.
-Listings~\ref{lst:wrap.c} and~\ref{lst:wrap} try to illustrate this by overriding the \texttt{malloc} function of the C standard library.
+Listings~\ref{lst:wrap.c} and~\ref{lst:wrap} illustrate this by overriding the \texttt{malloc} function of the C standard library.
 
 \begin{listing}[htbp]
   \inputminted[linenos]{c}{src/listings/wrap.c}
@@ -159,7 +157,7 @@ Therefore, the source code (or the corresponding \texttt{*.out} files) needs to
 Note, only calls from the targeted source code will be redirected, calls from other libraries won't.
 
 Theoretically, it should be possible to re-link a given binary without having access to its source code.
-But due to other more straight-forward methods (see Subsection~\ref{subsec:preloading}), this has not been further investigated.
+But due to other more straight-forward methods (see Subsection~\ref{subsec:preloading}), this has not been investigated further.
 
 
 \subsection{Preloading using \texttt{LD\_PRELOAD}}\label{subsec:preloading}
@@ -188,7 +186,7 @@ See the ld.so(8) Linux manual page~\cite[Section ENVIRONMENT]{ld.so.8}:
 \end{quote}
 
 This means, by setting the environment variable \texttt{LD\_PRELOAD}, it is possible to override specific functions.
-Listings~\ref{lst:preload.c} and~\ref{lst:preload} try to illustrate this by overriding the \texttt{malloc} function of the C standard library.
+Listings~\ref{lst:preload.c} and~\ref{lst:preload} illustrate this by overriding the \texttt{malloc} function of the C standard library.
 
 \begin{listing}[htbp]
   \inputminted[linenos]{c}{src/listings/preload.c}
@@ -211,17 +209,17 @@ The function \texttt{dlsym} is used to retrieve the original address of the \tex
 \cite{dlsym.3}
 
 By using this method, it is possible to override, and therefore wrap, any function as long as the targeted binary was not statically linked.
-Although, one has to be aware that not only function calls inside the targeted binary, but also calls inside other libraries (e.g., to \texttt{malloc}) are redirected to the overriding function.
+However, one must be aware that, not only function calls inside the targeted binary, but also calls inside other libraries (e.g., \texttt{malloc}), are redirected to the overriding function.
 
 
 \subsection{Conclusion}\label{subsec:methods-for-intercepting-conclusion}
 
 During the research on different approaches to intercepting system and function calls,
-it has been found that the most reliable way to achieve the goals of this work (see \todo{Goals}) is to intercept function calls instead of system calls.
-This is because (as long as the programs to test are dynamically linked), intercepting function calls allows one to intercept many more calls and in a more flexible way.
+it has been found, that the most reliable way to achieve the goals of this work (see Section~\ref{sec:motivation-and-goal}) is to intercept function calls instead of system calls.
+This is because---as long as the programs to test are dynamically linked---intercepting function calls allows one to intercept many more calls and in a more flexible way.
 Therefore, from now on this work only considers function calls and no system calls directly.
 
-In this work preloading (see Subsection~\ref{subsec:preloading}) was chosen to be used
+In this work, preloading (see Subsection~\ref{subsec:preloading}) was chosen to be used
 because it is simple to use (``clean'' source code, easy to compile and run programs with it) and offers the means to arbitrarily execute code when the intercepted function call is redirected.
 The following sections concern the next steps in what else is needed to create a powerful ``interceptor''.
 
@@ -231,7 +229,7 @@ The following sections concern the next steps in what else is needed to create a
 After deciding to use the preloading method to intercept function calls, a more detailed plan is needed to continue developing.
 It was decided to have one single \texttt{intercept.so} file as a resulting artifact which then may be loaded via the \texttt{LD\_PRELOAD} environment variable.
 The easiest and most straightforward way to structure the source code was to put all code in one single C file.
-Listing~\ref{lst:intercept-preload.c} gives an overview over the grounding code structure.
+Listing~\ref{lst:intercept-preload.c} gives an overview of the underlying code structure.
 For each function that should be intercepted, this function simply has to be declared and defined the same way \texttt{malloc} was.
 
 \begin{listing}[htbp]
@@ -244,8 +242,8 @@ For each function that should be intercepted, this function simply has to be dec
 \section{Retrieving Function Argument Values}\label{sec:retrieving-function-argument-values}
 
 Now that the first steps have been done, one needs to think about what exactly to record when intercepting.
-A simple notification that a given function was called would be too less.
-Within the following subsections it is tried to get as much information as possible from each function call.
+A simple notification that a given function was called would not be sufficient.
+Within the following subsections, effort is put into getting as much information as possible from each function call.
 
 As already mentioned, \texttt{ltrace} uses prototype functions to format its function arguments.
 This allows \texttt{ltrace} to ``dynamically'' display function arguments for any new or unknown functions without the need for recompilation.
@@ -255,13 +253,13 @@ However, due to implementation complexity reasons and the need for ``complex'' r
 This means that each function formats its arguments and return values itself without any configuration option.
 
 The reason for retrieving as much information as possible from each function call is that at a later point in time it is possible to completely reconstruct the exact function calls and their sequence.
-This allows analysis on these records to be performed independently of the corresponding execution of the program.
-It should always be possible for any parser to fully parse the recorded calls without any specific knowledge of specific functions, their argument types, or return value type.
+This allows an analysis on these records to be performed independently of the corresponding execution of the program.
+It should always be possible to fully parse the recorded calls without any specific knowledge of specific functions, their argument types, or return value type.
 
 
 \subsection{Numbers}\label{subsec:retrieving-numbers}
 
-The most simple types of argument are plain numbers, like integers (\texttt{int}, \texttt{long}, \ldots) or floating point numbers (\texttt{float}, \texttt{double}).
+The simplest types of arguments are plain numbers, like integers (\texttt{int}, \texttt{long}, \ldots) or floating point numbers (\texttt{float}, \texttt{double}).
 (In fact, \textit{all} arguments are represented as numbers or integers.
 See the following subsections for examples.)
 Plain numbers may be formatted simply as what they are, in base 10 notation, or with a prefix like \texttt{0x} for hexadecimal or \texttt{0} for octal representation.
@@ -270,8 +268,7 @@ Example: \texttt{malloc(123)} (or \texttt{malloc(0x7B)}).
 
 \subsection{Unspecific Pointers}\label{subsec:retrieving-unspecific-pointers}
 
-Pointers with no further information known about (like \texttt{void *}) are essentially integers.
-Therefore, they may be treated as such.
+Pointers without additional type information (such as \texttt{void *}) can essentially be treated as integers.
 
 Example: \texttt{free(0x55624164b2a0)}.
 
@@ -285,7 +282,7 @@ Special values inside the string are escaped with a backslash.
 
 Example: \texttt{sem\_unlink(0x1234:"/test-semaphore")}.
 
-Another type of ``string'' in C is a buffer with a known length.
+Another type of string-like data in C is a buffer with a known length.
 When buffers are used, usually another argument is passed to the function which indicates the length of the buffer.
 This fact may be used to print out the contents of the buffer in the same way as normal C strings.
 
@@ -293,7 +290,7 @@ Example: \texttt{write(3, 0x1234:"Test\textbackslash{}x00ABC", 8)}.
 
 \subsection{Flags}\label{subsec:retrieving-flags}
 
-Some functions have one of their arguments dedicated to flags which may be combined by bitwise XOR.
+Some functions have one of their arguments dedicated to flags which may be combined by bitwise XOR\@.
 These arguments are also of type integer.
 To distinguish flag arguments from others, a pipe symbol (\texttt{|}) is used after the colon and between the flags.
 
@@ -301,10 +298,10 @@ Example: \texttt{open(0x1234:"test.txt", 0102:|O\_CREAT|O\_RDWR|, 0644)}.
 
 \subsection{Constants}\label{subsec:retrieving-constants}
 
-For some functions constants are used.
-These constants are typically used C macros in the source code.
+For some functions, constants are used.
+These constants are typically implemented as C macros (\texttt{\#define}) in the source code.
 This makes the source code more readable (and portable).
-Constants are represented as an integer again followed by a colon, this time without any special characters to disdinguish them from other types.
+Constants are represented as an integer, again followed by a colon, this time without any special characters to distinguish them from other types.
 
 Example: \texttt{socket(2:AF\_INET, 1:SOCK\_STREAM, 6)}.
 
@@ -320,7 +317,7 @@ Example: \\
 
 \subsection{Pointers to Structures}\label{subsec:retrieving-pointers-to-structures}
 
-In rare cases structures (\texttt{struct}) are used as argument types.
+In rare cases, structures (\texttt{struct}) are used as argument types.
 Two curly brackets (\texttt{\{\}}) are used to indicate structures.
 Then the field names are displayed plainly, followed by a colon and then the value of that field.
 Commas are used to separate the fields respectively.
@@ -339,6 +336,10 @@ Example (\texttt{malloc}): \\
 \texttt{return 0x1234; errno 0}, \\
 \texttt{return -1; errno ENOMEM}.
 
+Some libc functions return their results via a pointer, which was previously given to them as an argument.
+The \texttt{pipe} function is called with an \texttt{int} array of size two as an argument and stores its two pipe ends into this array.
+The \texttt{read} function is called with a pointer to a buffer and a corresponding size and stores its read data into this buffer.
+
 Example (\texttt{pipe}): \\
 \texttt{return 0; errno 0; fildes=[3,4]}, \\
 \texttt{return -1; errno ENFILE}.
@@ -348,12 +349,13 @@ Example (\texttt{read}): \\
 \texttt{return -1; errno EINTR}.
 
 
+
 \section{Determining Function Call Location}\label{sec:determining-function-call-location}
 
-Besides from argument values and return values, it would be interesting to know from where inside the intercepted program the function call came from.
+Besides argument values and return values, it would be interesting to know from where inside the intercepted program the function call came.
 At first this seems quite impossible.
-But a function always knows at least the return address, the address to set then instruction pointer to when the function finishes.
-With this information it may be estimated where the call to the current function came from.
+But a function always knows at least the return address, the address to set the instruction pointer to when the function finishes.
+With this information, it may be estimated where the call to the current function came from.
 
 \subsection{Return Address and Relative Position}\label{subsec:return-address-and-relative-position}
 
@@ -405,11 +407,11 @@ typedef struct {
   \end{description}
 \end{quote}
 
-Using information from \texttt{Dl\_info}, it is possible to exactly determine the (shared) object from where the call came from (\texttt{dli\_fname}).
+Using information from \texttt{Dl\_info}, it is possible to exactly determine the (shared) object where the call came from (\texttt{dli\_fname}).
 Furthermore, it is possible to calculate the relative position inside this (shared) object using \texttt{dli\_fbase} and the return address itself.
 Keep in mind that the return address may only be used as an estimation for the origin of the call.
 Especially heavily optimized programs might use the same return address for functions in different code paths.
-Optionally, a name of a ``symbol'' (function) may be retrieved from where the function call came from.
+Optionally, a name of a ``symbol'' (function) may be retrieved, indicating where the function call came from.
 
 
 \subsection{Source File and Line Number}\label{subsec:source-file-and-line-number}
@@ -462,7 +464,7 @@ These other environment variables are described in the following:
     It is a list separated by commas, colons, or semicolons.
     Wildcards (\texttt{*}) at the end of function names are possible.
     A prefix of \texttt{-} indicates that the following function should not be intercepted.
-    Example: \texttt{*,-sem\_} intercepts all functions except those which start with \texttt{sem\_}.
+    Example: \texttt{*,-sem\_*} intercepts all functions except those which start with \texttt{sem\_}.
     By default, all (implemented) functions are intercepted.
   \item[\texttt{INTERCEPT\_LIBRARIES}]
     This variable is used to specify which libraries' function calls should be intercepted.
@@ -486,7 +488,7 @@ The shared object currently supports intercepting the following functions:
 
 \section{\texttt{intercept} Command}\label{sec:intercept-command}
 
-To make the usage of the aforementioned shared object more easy, a simple python script has been put together.
+To make the usage of the aforementioned shared object easier, a simple python script has been put together.
 This script may be used as a command line tool.
 See Listing~\ref{lst:intercept}.
 
@@ -544,25 +546,57 @@ This includes the offset relative to the calling binary and a source file and li
 
 \begin{listing}[htbp]
   \inputminted[fontsize=\tiny]{text}{src/listings/intercept-client.txt}
-  \caption{Recoreded function calls from \texttt{./client}.}
+  \caption{Recorded function calls from \texttt{./client}.}
   \label{lst:intercept-client}
 \end{listing}
 
 
 \section{Automated Testing on Intercepted Function Calls}\label{sec:automated-testing-on-intercepted-function-calls}
 
-The recorded function calls of a program run now may be used to perform checks and tests on them.
+The recorded function calls of a program run may now be used to perform checks and tests on them.
 It is trivially possible to check which functions were called and in what order.
 Furthermore, it is possible to check various pre- and post-conditions for each function call.
 This is beneficial because many library functions in C rely on these pre- and post-conditions, which are not enforced by the compiler or in any other way.
 
 For example, the \texttt{malloc} function has the post-condition that the returned value later needs to be passed to \texttt{free} to avoid memory leaks.
-The \texttt{free} function, on the other hand, has the pre-condition that the passed value was previously acquired using \texttt{malloc} and may not be yet free'd.
-Any violation of such pre- and post-conditions may be reported as incompliant behavior.
+The \texttt{free} function, on the other hand, has the pre-condition that the passed value was previously acquired using \texttt{malloc} and may not be yet freed.
+Any violation of such pre- and post-conditions may be reported as non-compliant behavior.
 \cite{malloc.3}
 
-This means that intercepted function calls allow a tester to check if programmers use library function in compliance to their specification.
+This means that intercepted function calls allow a tester to check whether programmers use library functions in compliance with their specifications.
 Other checks may also include guards to calls to ``forbidden'' functions, or that specific functions must be called exactly three times.
 Another important post-condition of most library functions is the return value, which in most cases indicates success or failure of an operation.
 However, intercepting of calls alone may not be able to verify if a program really checks the return value of a function and acts accordingly.
 Chapter~\ref{ch:manipulating-function-calls} shows how this problem may be solved.
+
+
+\subsection{Validating Memory Management}\label{subsec:testing-memory-management}
+
+The most basic memory management functions in the C standard library are the following.
+
+\begin{description}
+  \item[\texttt{malloc}, \texttt{calloc}]
+    Allocate memory. \cite{malloc.3}
+  \item[\texttt{realloc}, \texttt{reallocarray}]
+    Change the size of a previously allocated memory block and possibly move the block to another position in virtual memory. \cite{malloc.3}
+  \item[\texttt{free}]
+    Free previously allocated memory. \cite{malloc.3}
+  \item[\texttt{getaddrinfo}]
+    Allocate and initialize a linked list of \texttt{addrinfo} structures. \cite{getaddrinfo.3}
+  \item[\texttt{freeaddrinfo}]
+    Frees memory previously allocated by \texttt{getaddrinfo} for the dynamically allocated linked list. \cite{getaddrinfo.3}
+  \item[\texttt{getline}, \texttt{getdelim}]
+    Used to split strings.
+    Allocate memory on their own, which must be freed afterward. \cite{getline.3}
+\end{description}
+
+By only intercepting these functions, it is possible to check if all allocated memory blocks in a simple program were properly allocated and freed.
+
+
+\subsection{Validating Resource Management}\label{subsec:validating-resource-management}
+
+In addition to memory management, the proper use of other resources---most notably file descriptors---can also be checked.
+Many functions in the C standard library rely on file descriptors.
+It may be checked if file descriptors were properly acquired, if only previously acquired file descriptors are used, and if these file descriptors are closed after their use.
+Relevant for this work are also semaphores because they do not rely on file descriptor in their API\@.
+Due to time restrictions, no detailed list for validating resource management has been put together.

thesis/src/03.manipulate.tex

@@ -2,13 +2,13 @@
 \chapter{Manipulating Function Calls}\label{ch:manipulating-function-calls}
 
 This chapter discusses how to manipulate function calls and how this may be used to test programs.
-For how function calls may be intercepted at all, see Chapter~\ref{ch:intercepting-function-calls}.
+How function calls may be intercepted at all has been discussed in Chapter~\ref{ch:intercepting-function-calls}.
 This chapter builds on the basis of the previous one and expands its functions.
-``Manipulation'' in this context means to change the arguments of a function then running it normally, or skipping the execution of the real function completely and simply returning a given value (``mocking'').
+In this context, ``manipulation'' means changing the arguments of a function, before calling it with the modified arguments, or skipping the execution of the real function completely and simply returning a given value (``mocking'').
 These techniques allow in-depth testing of programs.
 
-In contrast to simply recording and logging function calls which may be controlled via environment variables, manipulation of such function calls requires some other process to indicate how to handle each call.
-This work uses simple sockets to communicate between the process of the program to be tested and a ``server'' which decides what action to perform for each function call.
+In contrast to simply recording and logging function calls, which may be controlled via environment variables, manipulation of such function calls requires some other process to indicate how to handle each call.
+This work uses simple sockets to communicate between the process of the program to be tested, and a ``server'', which decides what action to perform for each function call.
 Currently, only communication over Unix sockets is implemented, but communication over TCP sockets is also easily possible.
 
 Figure~\ref{fig:control-flow} illustrates the control flow for manipulating function calls.
@@ -35,21 +35,21 @@ Figure~\ref{fig:control-flow} illustrates the control flow for manipulating func
       \end{call}
     \end{sdblock}
 
-    \begin{sdblock}{Manipulated Call}{}
-      \begin{call}{p}{malloc(x)}{i}{return a}
+    \begin{sdblock}{Modified Call}{}
+      \begin{call}{p}{malloc(x)}{i}{return b}
         \mess{i}{{``malloc(x)''}}{s}
         \mess{s}{``modify y''}{i}
-        \begin{call}{i}{malloc(y)}{l}{return a}
+        \begin{call}{i}{malloc(y)}{l}{return b}
         \end{call}
-        \mess{i}{``return a''}{s}
+        \mess{i}{``return b''}{s}
       \end{call}
     \end{sdblock}
 
     \begin{sdblock}{Mocked Call}{}
-      \begin{call}{p}{malloc(x)}{i}{return z}
+      \begin{call}{p}{malloc(x)}{i}{return c}
         \mess{i}{{``malloc(x)''}}{s}
-        \mess{s}{``fail'' / ``return z''}{i}
-        \mess{i}{``return z''}{s}
+        \mess{s}{``fail'' / ``return c''}{i}
+        \mess{i}{``return c''}{s}
       \end{call}
     \end{sdblock}
   \end{sequencediagram}
@@ -62,7 +62,7 @@ Figure~\ref{fig:control-flow} illustrates the control flow for manipulating func
 \section{Defining a Protocol}\label{sec:defining-a-protocol}
 
 When using a socket to communicate with another process, a protocol definition is needed.
-This works defines a text-based protocol in which line breaks denote the end of a message.
+This work defines a text-based protocol in which line breaks denote the end of a message.
 The following subsections describe the defined message types.
 
 \subsection{\textit{Init} Message (Client \textrightarrow{} Server)}\label{subsec:init-message}
@@ -72,7 +72,7 @@ The client (\texttt{intercept.so}) uses it to identify the running program to th
 
 \subsection{\textit{Call} Message (Client \textrightarrow{} Server)}\label{subsec:call-message}
 
-For each function call the client sends this message to the server and waits for a reply (\textit{Action} message).
+For each function call, the client sends this message to the server and waits for a reply (\textit{Action} message).
 The contents of this message type correspond to the first line of an intercepted function call (see Section~\ref{sec:automated-testing-on-intercepted-function-calls}).
 
 \subsection{\textit{Action} Message (Server \textrightarrow{} Client)}\label{subsec:action-message}
@@ -91,14 +91,93 @@ The server responds in one of four possible ways:
 
 This message informs the server about the resulting return value.
 The server does not acknowledge this message.
-The contents of this message type correspond the second line of an intercepted function call (see Section~\ref{sec:automated-testing-on-intercepted-function-calls}).
-
-
-\section{Creating a Socket Server in Python}\label{sec:creating-a-socket-server-in-python}
-
-Lorem Ipsum.
+The contents of this message type correspond to the second line of an intercepted function call (see Section~\ref{sec:automated-testing-on-intercepted-function-calls}).
 
 
 \section{Automated Testing using Function Call Manipulation}\label{sec:automated-testing-using-function-call-manipulation}
 
-Lorem Ipsum.
+As seen in Figure~\ref{fig:control-flow} function call manipulation allows for mocking individual calls.
+Mocking may be used to see how the program behaves when individual calls to a function fail, or return an unusual, but valid, value.
+The simplest way to automatically test programs is to run them multiple times, allowing a single function call to fail in each run.
+The resulting sequence of function calls now may be put together to a call sequence graph (or tree).
+By analyzing this call graph, it is possible to decide if a program correctly terminated, when faced with a failed function call.
+This may be the case when the following function calls differ from those which were recorded on a default run (without any mocked function calls).
+
+
+\subsection{Testing Return Value Checks}\label{subsec:testing-return-value-checks}
+
+Figure~\ref{fig:call-sequence} shows the simplified and collapsed call sequence graph of the prior example in Section~\ref{sec:intercepting-example}.
+Each edge between two nodes without any label indicates the next function call on a normal run of the program.
+Edges labeled with ``fail'' indicate the next function call after a mocked failed call.
+In reality, there are multiple failing paths, one for each possible error return value.
+However, in this example they all yield the same resulting path, and have therefore been collapsed.
+
+To test if a programmer always checked the return value of a function and acted accordingly, this resulting call sequence graph now may be analyzed.
+At first glance, this test appears trivial.
+The simplest approach is to verify that after a failing function call only ``cleanup'' function calls (\texttt{free}, \texttt{close}, \texttt{exit}, \dots) follow.
+For simple programs, this assumption may hold, but there are many exceptions.
+For example, what if the program recognizes the failed call correctly as failed but recovers and continues to operate normally?
+Or what if the ``cleanup'' path is very complex and includes function calls not priorly marked as valid cleanup functions?
+However, for simple programs (like those mentioned in Section~\ref{sec:motivation-and-goal}), the simplest approach from above suffices.
+
+\begin{figure}
+  \begin{tikzpicture}[node distance=15mm, thick, main/.style = {draw, circle}, text centered]
+    \newcommand{\fncall}[2]{\tiny{\begin{tabular}{c}\normalsize{\texttt{#1}}\\\texttt{#2}\end{tabular}}}
+    \node[main] (1)[elips] {\fncall{getopt}{client+0x1ac5, client.c:186}};
+    \node[main] (2)[elips] [below of=1] {\fncall{getaddrinfo}{client+0x147b, client.c:74}};
+    \node[main] (3)[elips] [below of=2] {\fncall{socket}{client+0x14f2, client.c:81}};
+    \node[main] (4)[elips] [below of=3] {\fncall{connect}{client+0x15f3, client.c:104}};
+    \node[main] (5)[elips] [below of=4] {\fncall{freeaddrinfo}{client+0x1638, client.c:114}};
+    \node[main] (6)[elips] [below of=5] {\fncall{send}{client+0x1f5c, client.c:277}};
+    \node[main] (7)[elips] [below of=6] {\fncall{recv}{client+0x1fa1, client.c:284}};
+    \node[main] (8)[elips] [below of=7] {\fncall{recv}{client+0x2062, client.c:300}};
+    \node[main] (9)[elips] [below of=8] {\fncall{recv}{client+0x2442, client.c:360}};
+    \node[main] (10)[elips] [below of=9] {\fncall{recv}{client+0x2442, client.c:360}};
+    \node[main] (11)[elips] [below of=10] {\fncall{close}{client+0x2489, client.c:375}};
+    \node[main] (12)[elips] [below of=11] {\fncall{exit}{sys+0x0}};
+
+    \node[main] (2f1)[elips] [right=10mm of 2] {\fncall{exit}{sys+0x0}};
+    \node[main] (3f1)[elips] [right=10mm of 3] {\fncall{freeaddrinfo}{client+0x1638, client.c:114}};
+    \node[main] (4f1)[elips] [right=10mm of 4] {\fncall{close}{client+0x1611, client.c:106}};
+
+    \draw[->] (1) -- (2);
+    \draw[->] (2) -- (3);
+    \draw[->] (2) -- node[midway, above, sloped, pos=0.5] {fail} (2f1);
+    \draw[->] (3) -- (4);
+    \draw[->] (3) -- node[midway, above, sloped, pos=0.5] {fail} (3f1);
+    \draw[->] (3f1) -- (2f1);
+    \draw[->] (4) -- (5);
+    \draw[->] (4) -- node[midway, above, sloped, pos=0.5] {fail} (4f1);
+    \draw[->] (4f1) -- (3f1);
+    \draw[->] (5) -- (6);
+    \draw[->] (6) -- (7);
+    \draw[->] (7) -- (8);
+    \draw[->] (8) -- (9);
+    \draw[->] (9) -- (10);
+    \draw[->] (10) -- (11);
+    \draw[->] (11) -- (12);
+    \draw[->] (6) to [out=0,in=-4,looseness=2] node[midway, above, pos=0.05] {fail} (11);
+    \draw[->] (7) to [out=0,in=-2,looseness=1.75] node[midway, above, pos=0.075] {fail} (11);
+    \draw[->] (8) to [out=0,in=0,looseness=1.5] node[midway, above, pos=0.1] {fail} (11);
+    \draw[->] (9) to [out=0,in=2,looseness=1.25] node[midway, above, pos=0.1] {fail} (11);
+    \draw[->] (10) to [out=0,in=3,looseness=1] node[midway, above, pos=0.1] {fail} (11);
+  \end{tikzpicture}
+  \centering
+  \caption{Simplified Call Sequence Graph of \texttt{./client}.}
+  \label{fig:call-sequence}
+\end{figure}
+
+
+\subsection{Testing Correct Handling of Interrupts}\label{subsec:testing-interrupts}
+
+Many functions (like \texttt{read}, \texttt{write}, or \texttt{sem\_wait}) are interruptable by signals.
+When this happens, they return a value indicating an error and set \texttt{errno} to \texttt{EINTR}.
+Usually, the program is expected to repeat the call until it gets a real return value or error other than \texttt{EINTR}.
+Therefore, testing correct handling of interrupts is a different type of test in contrast to general tests on return value checks as seen in Subsection~\ref{subsec:testing-return-value-checks}.
+
+It is relatively simple to test if a program correctly handles interrupts.
+On any function call that may yield \texttt{EINTR} mock the call and return exactly that error.
+Afterward, check if the same function is called again.
+To increase confidence in the result, one may repeat this process multiple times.
+As in the test in Subsection~\ref{subsec:testing-return-value-checks}, the handling of the interrupt may involve calls to other functions, so this method is not always the right choice.
+But for simple programs, it totally suffices.

thesis/src/04.comparison.tex

@@ -1,4 +0,0 @@
-
-\chapter{Comparison to similar Solutions}\label{ch:comparison}
-
-Lorem Ipsum.

thesis/src/04.related-work.tex

@@ -0,0 +1,63 @@
+
+\chapter{Related Work}\label{ch:related-work}
+
+This chapter gives a rough overview on techniques and methods to intercept or hook system calls and function calls.
+See also Section~\ref{sec:methods-for-intercepting}.
+Many methods have already been discussed there.
+
+
+\section{Function Call Interception}\label{sec:function-call-interception}
+
+All related work regarding function call interception has already been mentioned in the aforementioned Section.
+See \texttt{ltrace} (Subsection~\ref{subsec:ltrace}), wrapper functions (Subsection~\ref{subsec:wrapper-functions}), and \texttt{LD\_PRELOAD} (Subsection~\ref{subsec:preloading}).
+
+
+\section{System Call Interception}\label{sec:system-call-interception}
+
+This section discusses further related work regarding system call interception.
+This excludes techniques already discussed in Section~\ref{sec:methods-for-intercepting},
+like \texttt{ptrace} (Subsection~\ref{subsec:ptrace}), and \texttt{strace} (Subsection~\ref{subsec:strace}).
+Almost all following methods use binary rewriting to replace system calls with other instructions (except SUD, Subsection~\ref{subsec:syscall-user-dispatch}).
+This is one of the reasons why they were not mentioned in Section~\ref{sec:methods-for-intercepting}.
+Another reason is that this work focuses on function call interception rather than system call interception.
+
+
+\subsection{\texttt{int3} Signaling}\label{subsec:int3-signaling}
+
+\texttt{int3} is a one-byte instruction (\texttt{0xcc}) that invokes a software interrupt.
+On Linux, the kernel handles it and raises \texttt{SIGTRAP} to the user-space process that executed \texttt{int3}.
+The \texttt{int3} signaling technique exploits this behavior to hook system calls; it replaces \texttt{syscall}/\texttt{sysenter} with \texttt{int3} and employs the signal handler for \texttt{SIGTRAP} as the hook function.
+Since \texttt{int3} is one byte, it can replace an arbitrary instruction without breaking neighboring instructions.
+This technique is traditionally used in debuggers to implement breakpoints.
+However, signal handling incurs a large overhead because it involves context manipulation by the kernel.
+\cite{zpoline}
+
+
+\subsection{Syscall User Dispatch (SUD)}\label{subsec:syscall-user-dispatch}
+
+Syscall User Dispatch (SUD)~\cite{sud} was added in Linux 5.11, and it offers a way to redirect system calls to arbitrary user-space code.
+For the SUD feature, the kernel implements a hook point at the entry point of system calls.
+A user-space process can activate SUD via the \texttt{prctl} interface.
+When SUD is activated, the hook point raises \texttt{SIGSYS} to the user-space process.
+This mechanism allows a user-space program to leverage the \texttt{SIGSYS} signal handler as the system call hook.
+However, similarly to the \texttt{int3} signaling technique, SUD imposes a significant performance penalty on the user-space program due to the overhead of the signal handling.
+\cite{zpoline}
+
+
+\subsection{zpoline}\label{subsec:zpoline}
+
+zpoline is a system call hook mechanism for x86-64 CPUs.
+Binary rewriting is used to replace (two-byte) \texttt{syscall}/\texttt{sysenter} instructions with a (two-byte) \texttt{callq *\%rax} instruction.
+Because this instruction jumps to \texttt{rax}, where also the syscall number is stored, the trampoline code has to be initialized beginning at virtual address 0.
+zpoline is exhaustive and achieves very low performance reduction (28--761 times less overhead compared to other exhaustive system call hooking techniques).
+\cite{zpoline}
+
+
+\subsection{DataHook}\label{subsec:datahook}
+
+DataHook is a system call hooking technique for 32-bit programs based on glibc running on x86 or x86-64 machines.
+It relies on glibc's way of performing system calls, namely a \texttt{call *\%gs:0x10} instruction to call the \texttt{\_\_kernel\_vsyscall} function.
+The content of \texttt{gs:0x10} is backed up and modified to jump to a given hook function.
+DataHook is only exhaustive when used on glibc-based programs.
+It achieves a very low performance reduction (5--1429 times less overhead compared to existing hooking techniques).
+\cite{datahook}

thesis/src/05.evaluation.tex

@@ -0,0 +1,157 @@
+
+\chapter{Evaluation}\label{ch:evaluation}
+
+This chapter evaluates the developed approach in terms of both its practical usefulness and its performance.
+Section~\ref{sec:usefulness} examines how well the library and tools support automated testing in the context of the Operating Systems course.
+Section~\ref{sec:performance} analyzes the performance overhead introduced by intercepting function calls.
+
+
+\section{Usefulness for the Operating Systems Course}\label{sec:usefulness}
+
+Up until recently the Operating Systems course (mentioned in Section~\ref{sec:motivation-and-goal}) was split into three exercise blocks:
+Files, Shared Memory, Semaphores; Related Processes and Inter-Process Communication via Unnamed Pipes; and Sockets.
+Table~\ref{tab:functions} lists all functions presented in the course and their implementation status in \texttt{intercept.so}.
+As one may see, simple file stream functions are not currently implemented in \texttt{intercept.so}.
+This is because of time restrictions on this work, and the fact that simple file operations may be tested easily in the conventional way of checking the resulting output.
+Note that the future implementation of single functions is not very complex.
+All other functions have at least interception and mocking (returning, failing) implemented.
+For some functions the modification of function arguments has been implemented.
+
+\begin{table}[h!]
+  \centering
+  \begin{threeparttable}
+    \begin{tabular}{ c|l|c }
+      Ex. Block & Functions                                           & Implementation \\
+      \hline
+      - & malloc, calloc, realloc, reallocarray, free                 & \texttt{icmrf} \\
+      - & getopt                                                      & \texttt{ic-rf} \\
+      - & sigaction                                                   & \texttt{ic-{}-f} \\
+      - & mmap                                                        & \texttt{ic-rf} \\
+      - & munmap                                                      & \texttt{icmrf} \\
+      - & close                                                       & \texttt{icmrf} \\
+      \hline
+      1 & open, fopen, fdopen                                         & \texttt{-{}-{}-{}-{}-} \\
+      1 & read, pread, write, pwrite                                  & \texttt{ic-rf} \\
+      1 & fread, fgets, fgetc, fwrite, fputs, fputc, fprintf, fseek   & \texttt{-{}-{}-{}-{}-} \\
+      1 & ferror, feof, clearerr, fileno, fflush, fclose              & \texttt{-{}-{}-{}-{}-} \\
+      1 & getline, getdelim                                           & \texttt{ic-rf} \\
+      1 & shm\_open, ftruncate, shm\_unlink                           & \texttt{icmrf} \\
+      1 & sem\_open, shm\_close, sem\_unlink                          & \texttt{icmrf} \\
+      1 & sem\_wait, sem\_post                                        & \texttt{icmrf} \\
+      1 & sem\_trywait, sem\_timedwait                                & \texttt{icmrf} \\
+      1 & sem\_getvalue, sem\_destroy                                 & \texttt{icmrf} \\
+      \hline
+      2 & fork, wait, waitpid                                         & \texttt{icmrf} \\
+      2 & exec*, fexecve                                              & \texttt{ic-rf} \\
+      2 & exit                                                        & \texttt{icm-{}-} \\
+      2 & pipe                                                        & \texttt{ic-rf} \\
+      2 & dup, dup2, dup3                                             & \texttt{icmrf} \\
+      \hline
+      3 & socket, bind, accept, connect                               & \texttt{ic-rf} \\
+      3 & listen                                                      & \texttt{icmrf} \\
+      3 & getaddrinfo                                                 & \texttt{ic-rf} \\
+      3 & freeaddrinfo                                                & \texttt{icmrf} \\
+      3 & send, recv                                                  & \texttt{ic-rf} \\
+      3 & sendto, sendmsg, recvfrom, recvmsg                          & \texttt{ic-rf} \\
+      3 & setsockopt                                                  & \texttt{-{}-{}-{}-{}-} \\
+    \end{tabular}
+    \begin{tablenotes}
+      \item[\texttt{i}] Function may be intercepted.
+      \item[\texttt{c}] Complex function arguments or return value(s) are recorded fully.
+      \item[\texttt{m}] Function arguments may be modified.
+      \item[\texttt{r}] Function may be mocked using a specified return value.
+      \item[\texttt{f}] Function may be mocked using a specified error value.
+    \end{tablenotes}
+    \caption{List of relevant functions and their implementation status.}
+    \label{tab:functions}
+  \end{threeparttable}
+\end{table}
+
+
+\section{Performance}\label{sec:performance}
+
+Although high performance was not a primary goal of this work, the performance degradation caused by interception and manipulation should not be excessive.
+The following two subsections test and discuss the performance degradation of \texttt{intercept.so} compared to running a program without any intercepting or hooking.
+
+
+\subsection{Performance when Intercepting}\label{subsec:performance-intercepting}
+
+To test the performance of \texttt{intercept.so}, the following measurement environment was set up.
+On an x86-64 machine with an AMD Ryzen 7 7700X 8-Core processor, a simple program was called with an increasing number of iterations it had to perform.
+The program simply called the \texttt{pipe} function and then closed the created pipes in a for loop.
+At first execution time of the program was measured without using \texttt{intercept.so} (``Baseline'').
+Then \texttt{intercept.so} was preloaded, but without any action to perform when intercepting (``Intercepting'').
+After that, logging to \texttt{stderr} was enabled (``Logging to stderr'').
+Finally, the logs were written to a file (``Logging to file'').
+For each of the four variants, the program was called with an iteration count beginning at 100 and increasing in steps of 100 up to 5000.
+Each measurement was taken 30 times, with one second between program executions to rule out statistical outliers.
+Figure~\ref{fig:performance} illustrates the results.
+
+It is clearly visible that the initialization step of \texttt{intercept.so} always takes around 10 ms.
+In comparison to that, the performance degradation of the intercepting procedure alone is negligible, only around +13\% compared to the baseline execution (see ``Intercept -- 10 ms'' and ``Baseline'').
+Most of the delay is caused by logging the recorded function calls.
+
+\begin{figure}
+  \centering
+  \begin{tikzpicture}
+    \begin{axis}[
+        xmin=100, xmax=5000,
+        ymin=0, ymax=150,
+        scaled y ticks=false,
+        ymajorgrids=true,
+        grid style=dashed,
+        legend pos=north west,
+        legend cell align={left},
+        width=\textwidth,
+        xlabel=Iterations,
+        ylabel=Execution Time,
+        x unit=\#,
+        y unit=\si{\milli\second},
+      ]
+
+      \addplot[color=blue] table [x=Cycles, y expr=\thisrow{Baseline Avg}/1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addlegendentry{Baseline}
+      \addplot[name path=a_top,color=blue!50,forget plot] table [x=Cycles, y expr=(\thisrow{Baseline Avg} + \thisrow{Baseline SD}) / 1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addplot[name path=a_down,color=blue!50,forget plot] table [x=Cycles, y expr=(\thisrow{Baseline Avg} - \thisrow{Baseline SD}) / 1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addplot[blue!20,fill opacity=0.2] fill between[of=a_top and a_down];
+      \addlegendentry{Baseline ±SD}
+
+      \addplot[color=green] table [x=Cycles, y expr=\thisrow{Intercept Avg}/1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addlegendentry{Intercepting}
+      \addplot[name path=b_top,color=green!50,forget plot] table [x=Cycles, y expr=(\thisrow{Intercept Avg} + \thisrow{Intercept SD}) / 1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addplot[name path=b_down,color=green!50,forget plot] table [x=Cycles, y expr=(\thisrow{Intercept Avg} - \thisrow{Intercept SD}) / 1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addplot[green!20,fill opacity=0.2] fill between[of=b_top and b_down];
+      \addlegendentry{Intercepting ±SD}
+
+      \addplot[color=teal] table [x=Cycles, y expr=(\thisrow{Intercept Avg} - 10000000) / 1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addlegendentry{Intercepting -- 10 ms}
+
+      \addplot[color=red] table [x=Cycles, y expr=\thisrow{Stderr Avg}/1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addlegendentry{Logging to stderr}
+      \addplot[name path=c_top,color=red!50,forget plot] table [x=Cycles, y expr=(\thisrow{Stderr Avg} + \thisrow{Stderr SD}) / 1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addplot[name path=c_down,color=red!50,forget plot] table [x=Cycles, y expr=(\thisrow{Stderr Avg} - \thisrow{Stderr SD}) / 1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addplot[red!20,fill opacity=0.2] fill between[of=c_top and c_down];
+      \addlegendentry{Logging to stderr ±SD}
+
+      \addplot[color=orange] table [x=Cycles, y expr=\thisrow{File Avg}/1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addlegendentry{Logging to File}
+      \addplot[name path=d_top,color=orange!50,forget plot] table [x=Cycles, y expr=(\thisrow{File Avg} + \thisrow{File SD}) / 1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addplot[name path=d_down,color=orange!50,forget plot] table [x=Cycles, y expr=(\thisrow{File Avg} - \thisrow{File SD}) / 1000000, col sep=semicolon] {src/performance/stat.csv};
+      \addplot[orange!20,fill opacity=0.2] fill between[of=d_top and d_down];
+      \addlegendentry{Logging to File ±SD}
+    \end{axis}
+  \end{tikzpicture}
+  \caption{Execution times of a simple program using \texttt{intercept.so} with different output modes.}
+  \label{fig:performance}
+\end{figure}
+
+
+\subsection{Performance when Manipulating}\label{subsec:performance-manipulating}
+
+Measuring performance for function call manipulation makes no sense without knowing the exact socket server to be used.
+As seen in Subsection~\ref{subsec:performance-intercepting}, most delay comes not from intercepting itself, but from the further processing.
+This also applies to function call manipulation.
+The performance degradation heavily depends on the response speed of the used socket.
+Therefore, an explicit performance test on manipulation was deemed unlikely to yield meaningful results and was not carried out.
+
+\todo{Simple performance test}

thesis/src/05.related-work.tex

@@ -1,12 +0,0 @@
-
-\chapter{Related Work}\label{ch:related-work}
-
-Lorem Ipsum.
-
-What other solutions are available?
-What are the differences?
-What are the characteristics?
-
-
-https://sholtrop.dev/blog/on-intercepting-linux-syscalls/
-https://github.com/yasukata/zpoline

thesis/src/06.conclusion.tex

@@ -1,9 +1,25 @@
 
 \chapter{Conclusion}\label{ch:conclusion}
 
-Lorem Ipsum.
+\todo{Start with Goals in OSVU}
 
-Perhaps do some study/``research'' on performance (CPU/memory/\dots).
+This work presented \texttt{intercept.so}, a shared object file intended to be preloaded using \texttt{LD\_PRELOAD}, which may be used to intercept function calls on Linux systems.
+Furthermore, a supporting Python program, \texttt{intercept}, was presented to make the shared object easier to use.
+By using preloading to hook or intercept function calls, the overhead and performance degradation remain negligible for the purpose of testing student submissions.
+To make use of intercepted function calls, some techniques of automatic testing of simple C programs were discussed.
 
-%\attachfile[appearance=false,print=false,mimetype=text/plain,description=intercept.c]{../proj/intercept/src/intercept.c}
-%\attachfile[appearance=false,print=false,mimetype=text/plain,description=Makefile]{../proj/intercept/Makefile}
+In addition, the work has shown that creating an automated testing tool for the Operating Systems course assignments is both feasible and practical.
+The evaluation indicates that performance overhead is negligible and therefore not a hindrance to real-world use.
+Finally, since the approach relies on standard and portable mechanisms, the solution can be considered future-proof and adaptable to other environments.
+
+The source code of the programs developed in this work is attached below.
+(Not all PDF viewers may open/download attachments.)
+
+\texttt{intercept.so}:
+\textattachfile[mimetype=text/plain]{../proj/intercept/src/intercept.c}{\textcolor{blue}{\texttt{intercept.c}}} (source code), and
+\textattachfile[mimetype=text/plain]{../proj/intercept/Makefile}{\textcolor{blue}{\texttt{Makefile}}}.
+
+\textattachfile[mimetype=text/plain]{../proj/intercept/intercept}{\textcolor{blue}{\texttt{intercept}}} (Python program).
+
+Automatic testing:
+\textattachfile[mimetype=application/zip]{src/attachments/auto-test.zip}{\textcolor{blue}{\texttt{auto-test.zip}}} (zipped Python programs).

thesis/src/99.intercept.bib

@@ -37,6 +37,12 @@
 @manual{malloc.3,
     title = {malloc(3) -- Library Functions Manual -- Linux manual pages},
 }
+@manual{getaddrinfo.3,
+    title = {getaddrinfo(3) -- Library Functions Manual -- Linux manual pages},
+}
+@manual{getline.3,
+    title = {getline(3) -- Library Functions Manual -- Linux manual pages},
+}
 @book{netsectools2005,
     author = {Dhanjani, Nitesh and Clarke, Justin},
     title = {Network Security Tools},
@@ -46,7 +52,49 @@
     publisher = {O'Reilly},
     url = {https://litux.nl/mirror/networksecuritytools/0596007949/toc.html},
 }
+@book{linuxkernel,
+    author = {Daniel P. Bovet and Marco Cesati},
+    title = {Understanding the Linux Kernel},
+    subtitle = {From I/O Ports to Process Management},
+    edition = {3rd},
+    date = {November 2005},
+    isbn = {978-0-596-00565-8},
+    publisher = {O'Reilly},
+}
 @manual{gcc,
     title = {Using the GNU Compiler Collection (GCC)},
     url = {https://gcc.gnu.org/onlinedocs/gcc/index.html},
 }
+@manual{sud,
+    title = {Syscall User Dispatch -- The Linux Kernel documentation},
+    url = {https://docs.kernel.org/admin-guide/syscall-user-dispatch.html},
+}
+@inproceedings{zpoline,
+    author = {Kenichi Yasukata and Hajime Tazaki and Pierre-Louis Aublin and Kenta Ishiguro},
+    title = {zpoline: a system call hook mechanism based on binary rewriting},
+    booktitle = {2023 USENIX Annual Technical Conference (USENIX ATC '23)},
+    year = {2023},
+    isbn = {978-1-939133-35-9},
+    address = {Boston, MA},
+    pages = {293--300},
+    url = {https://www.usenix.org/conference/atc23/presentation/yasukata},
+    publisher = {USENIX Association},
+    month = jul,
+}
+@article{datahook,
+    author = {Hong, Quan and Li, Jiaqi and Zhang, Wen and Zhai, Lidong},
+    title = {DataHook: An Efficient and Lightweight System Call Hooking Technique without Instruction Modification},
+    year = {2025},
+    issue_date = {July 2025},
+    publisher = {Association for Computing Machinery},
+    address = {New York, NY, USA},
+    volume = {2},
+    number = {ISSTA},
+    url = {https://doi.org/10.1145/3728874},
+    doi = {10.1145/3728874},
+    journal = {Proc. ACM Softw. Eng.},
+    month = jun,
+    articleno = {ISSTA005},
+    numpages = {21},
+    keywords = {DataHook, Hooking technique, Software analysis, Software debugging, System call}
+}

thesis/src/performance/perf-1.csv

@@ -0,0 +1,50 @@
+0324229;0344789;0315172;0366980;0451151;0462482;0446011;0296485;0465337;0405983;0343554;0440008;0465907;0449405;0348523;0361888;0358973;0335639;0323174;0333324;0434446;0444885;0455145;0433704;0316631;0440787;0464201;0453772;0438272;0314808
+0613534;0585481;0624114;0707201;0626529;0729825;0782584;0682264;0592513;0788676;0615306;0619885;0818591;0608523;0603173;0642398;0606199;0794877;0647046;0624163;0786830;0623031;0630574;0588264;0766903;0706558;0741855;0920262;0822026;0635223
+0915874;0929220;1354985;1253021;0970777;0876259;0918032;0873931;0920173;1045615;1097067;0876029;0905656;1020317;0950143;0951745;1152357;0927634;1178937;1007000;1016156;1086956;0890182;0928126;0877984;1030849;0931188;1325593;0972338;0960041
+1457189;1225447;1443298;1345482;1255010;1345018;1228475;1480843;1238893;1185135;1416952;1351642;1326401;1356037;1200298;1234515;1257900;1182870;1175615;1307243;1238887;1271089;1275817;1269635;1331454;1376381;1361040;1392340;1314486;1278415
+1521309;1644208;1452842;1587104;1814898;1534939;1578423;1540678;1507091;1548842;1521678;1638374;1487388;1752173;1573874;1508567;1487365;1667193;1762838;1807674;1541997;1453635;1574287;1723888;1569727;1498438;1784162;1593661;1551629;1538803
+1822231;1856406;1896143;1744459;1909036;1804293;2031491;1835551;1764232;1930073;1751766;2003322;1839696;1984855;1865374;1884680;1781369;1920989;1838749;1832316;2312261;1831192;1808037;1838015;1866569;1938166;1789449;2026515;2255656;1900361
+2249322;2038867;2235614;2346377;2350745;2435958;2226564;2220021;2186657;2418702;2076484;2216182;2111830;2137850;2214567;2388661;2044799;2188625;2183625;2099032;2230664;2376744;2157352;2189644;2171629;2132283;2277501;2172709;2148432;2187367
+2840629;2714056;3141806;2771946;2452543;2438436;2583173;2758749;2733540;2701128;2338241;2385792;2315547;2598459;2463330;2686587;2569853;2778734;2605430;2459150;2497503;2617182;2874473;2881476;2731159;2360229;2800070;2855626;2305833;2588464
+2978300;2626996;2933804;2631274;3037121;2939714;3036780;2841646;2610784;2877925;2946946;2634919;2657963;2935193;2753896;2737855;2756861;2829440;3144120;3112911;2776608;3107951;2616942;2708567;2764044;2815251;2860607;2597754;2755776;2746568
+2999501;2902085;2940890;3118959;3049757;2920500;3238958;3070095;3217436;2939725;3034706;3040568;3048622;3480659;2993758;2893466;2930207;3083369;3046619;3269283;3239346;3517567;3081805;3383581;3234205;3369042;2918031;3161585;3067757;3071072
+3543013;3210018;3363180;3404129;3413245;3500030;3192354;3387165;3357448;3659976;3444655;3337371;3357308;3506982;3391863;3432280;3403546;3654543;3171783;3366734;3207305;3389343;3181995;3563026;3181420;3687811;3437920;3353197;3630820;3452862
+3575325;3688759;3666803;3519527;3884132;3680724;3482566;3721951;3699715;3858539;3868556;3597023;3690668;3687269;3970321;3472939;3639528;3643774;3965451;3642107;4044074;3741771;3642391;4113987;3770622;3684498;3595078;3832436;3670054;3722726
+4098397;3995101;3962495;4017150;3984825;4076955;3949461;4158994;4043784;4190313;4131274;3785438;4133945;4241796;4129853;4145823;4148908;4294683;4218621;4174221;4005968;3874757;3936558;4056813;3959610;4040818;4166043;4149699;3911579;4640181
+4666722;4289677;4486504;4537451;4197031;4297046;4320099;4110465;4325216;4077628;4070002;4295042;4295442;4443802;4370365;4095314;4266498;4286406;4423824;4323537;4304137;4504107;4540978;4272880;4295273;4306995;4059830;4100668;4306720;3905504
+4921671;4576855;4588897;4761663;4429743;4209511;4905470;4367176;4751576;4808977;4805048;4390056;4327562;4162519;4448166;4151796;4899454;4805249;4608714;4807731;4501893;4559895;4592558;4567107;4779029;4553147;4563767;4534558;4598853;4187771
+4866412;4869016;4860007;5015458;4884161;4776511;4907164;5362039;4501933;4871731;4992255;4878543;4975771;5257238;5042218;5221004;4782161;5216373;4757570;4697362;4897109;4883963;4900504;5029424;4868490;4722535;4913435;4952309;4922270;4867503
+5138528;4961783;5176560;4987482;5190235;5459997;5166306;5177587;5164812;4942039;5194908;5430193;5182462;5310149;5183853;5203380;5316989;5303472;4959744;4895729;5276517;4969250;5143317;5426855;5161872;4968726;5017229;5187859;5360593;5136067
+5468701;5814780;5631965;5476333;5513444;5553019;5488523;5540473;5379340;5533458;5494401;5182107;5262482;5583331;5671130;5509617;5498294;5485950;5173895;5466340;5472922;5190205;5412223;6033795;5241181;5893292;5456006;5467467;5844846;5193015
+5738819;5522430;5510727;5906672;6174729;5763864;5888906;5784903;5692284;5815631;5772979;5899081;5500902;6141739;5893980;5713551;5799847;6178798;5465631;5998278;5806657;6073402;5835843;5788070;5906518;5790504;5683216;5906556;5753901;5470253
+6051224;5853592;5934538;6381208;6163197;5902213;6338564;5936909;6069013;6060837;6042190;6102977;6099901;5932788;6298162;5861319;5900565;5800281;6063357;6143431;6113644;6201321;6114784;6089395;5833772;6054787;6204686;5948933;6061999;6235313
+6334033;6503689;6375742;6404467;6392042;6039363;6440515;6339781;6364037;6065501;6471493;6397490;6674824;6052194;7032291;6207503;6381838;6353212;6389221;6367639;6337761;6337401;6421131;6386814;6255982;6113748;6369469;6456697;6455174;6611194
+6500330;6330062;6706075;6530317;6545385;6532019;6746963;6367983;6374284;6738575;6658921;6645455;6625366;6705981;6371367;6521666;6565369;6528658;6409448;6588152;6686110;6872779;6931501;6857389;6880863;6664567;7105414;6807551;6495671;6399406
+6672330;7073361;7003998;7313331;7286610;6973387;6791678;7007021;6786347;6936355;7017571;7090400;6956823;7053469;6974257;6741489;7023371;7066012;6704467;6702964;6961631;7228754;6986307;6627607;6970396;7006134;7066470;6943243;6972048;6649338
+7326499;6962068;7266563;6911431;7462178;7379429;7796530;7496644;7800658;6952198;7276780;7273864;7364660;7245771;7339941;7351613;6947847;7330041;7364036;7332135;7186375;7249486;7588767;6927196;7364305;7021887;7307105;7319319;7253522;7270134
+7605948;8106489;7805682;7375825;7690209;7613973;7679068;7482199;7350757;7900632;7722369;7670059;7866947;7794157;7615304;7562592;7270330;7699114;8007345;7682792;7729732;8174395;7822039;7879138;7744039;7683843;7272843;7601895;7643134;7559734
+7928582;7910006;8049483;7914033;7906459;8521379;7872453;7892230;7672409;8272740;7554071;7561696;7603175;7864076;7817285;7563207;7245287;7552497;8043710;7093626;7212603;7360498;7211181;7478755;7164732;7218655;7125666;7212874;7508260;7647347
+7795712;8189357;8138329;8263359;7993991;8296863;8169899;8252447;8326590;8345626;7768749;8307903;8215035;8545789;8187060;8267886;8121204;8176110;7862778;8165839;8127185;8412582;8161440;8153586;8275249;8146752;8257865;7784196;8172511;8354911
+8509087;8472547;8556136;8149416;8064152;8656670;8636982;8759796;8126973;8741542;8494968;8511900;8489908;8269115;8147281;8613495;8477174;8233837;8552961;8573412;8564692;8660451;8334490;8491870;8817286;8494411;8176416;8535077;8065682;8259255
+9021408;9136504;8445680;9025541;8849087;8438188;8813432;8952717;8906071;8857573;9025104;8934421;8578332;8992964;8813034;8868994;8813651;8376131;8627668;8878325;8830336;8508645;8807889;8842191;9219348;8909922;8368578;8628140;8805960;8858072
+9165009;9231217;8940279;9095003;8673075;9083977;9237289;9130926;9013212;9188447;8658465;8834113;9663822;8645004;8962029;9159057;9091280;9155537;8662509;9054493;9093007;8663436;8781098;8663624;9068540;8634582;9265467;9169776;9233269;9105966
+9494692;9402799;9235076;9546139;9322324;9415174;9427840;9537654;9036835;9726283;9440307;9275539;9195141;9210358;8918362;9067712;9809575;9642563;9056945;8956367;9382505;9823413;8978025;9338383;9640287;8944885;9580745;9045238;9057522;9424413
+9782625;9239275;9224354;9707052;9351080;9434503;9755974;9517734;9231229;9666724;9864591;9994684;10018802;9888142;10011815;9918670;9792890;9901353;9767967;10056683;9790830;9975800;9727751;9830320;10516850;9778887;9734109;9886525;9911625;10084201
+10000195;9657851;10232236;9721483;10272232;10016879;10160961;9999312;9637100;9684352;10133281;10266039;9621855;9506405;10211818;9746004;9830228;10158550;9512922;9790525;10048308;10416881;9515451;9647550;10224178;9529746;10121305;10163877;9517568;9928403
+10421768;10132969;10688426;10106906;9929647;9990827;10390417;9905767;10412267;10336458;10398738;10451902;10050624;10371300;10009783;10386547;10629280;9950772;10657985;10555623;10345132;10563586;9917612;9803696;9818786;9904371;10589441;10159587;10318529;10403945
+10630706;10658080;10134293;10644078;10512329;10779992;10615529;10235465;10254680;10743145;10145775;10793069;10781414;10739041;10107624;10809416;10704560;10106159;10388940;11319617;10696679;10791312;10298459;10657870;10583182;10718226;10090427;10640961;10426181;10465607
+10881488;10359257;10713408;11308689;10958643;10947421;10594802;11056832;10654325;11324492;10553266;11139979;10534968;10896953;11190675;10522390;10992949;11168639;10592655;10962695;10920771;11070554;11426587;11333895;11180383;10985984;11212145;10922637;10661087;10901002
+11155829;11647177;11442615;11427946;11287331;11305155;11267792;11245226;11291314;10809125;11308054;10790957;11328274;11265658;10882993;11572356;11603765;11310783;11013995;11225976;10908797;11530358;10785325;10880840;11292301;10857663;11254275;11960429;10766084;11165761
+11515911;11448687;12109624;11078907;11353942;11025461;11787301;11607812;11628984;11300612;11006328;10985637;11817685;11574872;11463794;11816110;11556414;11935440;11761751;11298519;11251307;11604292;11393801;11733662;11599839;11098945;11390191;11551034;11580639;12167329
+11923365;12048197;11972059;11901269;11280200;11700326;11320036;11419519;12074680;11211723;11616349;12064199;11351802;12175041;11366240;11998317;12299611;12037641;11340395;11556376;12334456;12227778;12067245;12124957;11866132;11973230;12041422;12073812;11953157;11405624
+12165580;12072636;11948004;12189664;12181347;11749946;12493871;12468883;12070215;12804270;12241448;11720767;12386840;12541347;11735673;11931434;12306871;11889510;11536743;12381752;12143971;11920557;12159750;11936934;12076798;12210566;12254710;11540395;12268377;12387466
+12860132;12326958;12498590;13018087;13087401;11969921;11935164;12709205;12695297;11853071;12625670;12549392;12505166;12618296;12592202;12466949;12762272;12707935;12544596;12846364;12704987;11894035;11878815;12608740;12637082;12030917;12633435;13020382;12547248;12669562
+12883407;12871883;13135373;12804562;12850540;12982435;12201361;12916256;13116836;12700795;12925553;12588587;12515887;12196458;12134657;12317409;12609595;12454023;12789023;12834291;12821393;12848275;12917449;12845869;12890947;12606473;12596182;12212699;12944367;12964774
+13103532;12555711;13224236;12699930;13022374;13055685;13031392;12493757;13341830;13369392;13101625;13567236;13289496;13090599;13194350;13109376;13030624;13056702;13179199;13222071;13141274;13041311;12746400;13334358;13441633;13359063;13234561;12677644;13404980;13216927
+12862878;13032789;13852354;12997780;13633951;12851015;13445744;13751910;12949793;13557710;13356249;12893515;13608246;13386846;13515756;13208681;13422364;13931650;13719038;13240160;13395459;12921144;13428833;13335593;12971158;13474902;12714910;13144049;13034497;13453207
+13758577;14074689;13842176;13661048;14205731;13434579;13761890;13684310;14184878;13995821;13949449;13272981;14397487;13373295;13611946;13790602;13158790;14006147;13174148;14033529;13842098;13652441;13585632;12963639;13200787;13505694;13645906;13266103;13759266;14130262
+13933161;14529924;14379613;13568303;13590316;14588294;13754692;13670109;13977613;14016046;13735353;13678745;14379368;13794515;13531497;13966768;13582285;14018658;14309581;14735985;14100767;14101857;13900937;14350096;13724817;14134419;13547224;13678206;13706581;14338198
+13650840;14458753;13829225;13584172;14928740;13582498;14444343;15004536;13676589;13607125;13863628;14244043;13971536;13659059;14758977;14583799;14669985;14561905;14493144;14025527;14428236;14550140;13574475;13653098;14306539;13801353;14810051;14648670;14328320;14719374
+14419936;14946733;15384388;14470703;13993701;13871395;14440644;14565295;14734231;14393641;14839072;15116748;14812198;14104511;14849931;14186210;14691525;14922883;14630817;14767651;14382705;15069311;14018471;14705129;14743412;14706220;13964758;14108124;14621616;14839176
+14845317;14986819;14241920;15045270;14663814;14194859;14682600;14389995;14946089;14419522;14734641;15116264;14320088;14851865;14619940;14832787;14418988;15109371;14928601;14747262;14904333;14963168;14426211;15066025;14295507;14603794;14952884;15001387;14620524;14327327
+15629681;15281389;15345592;15363897;15640709;15488638;14675978;15458107;15023250;15577887;14696205;15337242;14731703;14935758;14813301;15280823;14479005;15668852;15016680;14700830;15443718;15528250;15400795;15071165;15242125;14832384;15422923;14714997;15544939;15649651

thesis/src/performance/perf-2.csv

@@ -0,0 +1,50 @@
+12386073;10054904;10597530;10062469;10451459;11034914;10769732;11010135;10524027;10147651;10461115;10720075;10047908;10613609;10119276;10479631;10334140;10275777;10011367;10301939;10350272;10102642;10549503;10370889;10089536;10160502;10226790;10315121;10005193;10239204
+10584811;10799245;10733036;10760640;10483565;10719952;10964843;10416144;10277045;10792098;10889276;10699349;10522378;10982295;11079964;10666897;10749746;10733044;11106365;10533569;11455658;10212830;10819980;11010147;10349163;10321499;10921095;10638539;10779761;10864295
+11407642;10962984;11056495;10588132;11362034;11362956;10934760;10533777;10909500;10527444;11040844;11311345;10895954;10657594;10913257;11412089;10719012;11187715;11341572;11652031;11275384;10772024;10694434;10536729;10627605;10773096;10786882;10768046;10823863;11026023
+11234695;11389954;11708298;11275684;11204585;11438636;11389591;11585911;11572184;11614887;10858477;11351198;11100384;11802307;11590650;11242938;11086898;11357500;10938592;11885277;11372497;11072560;11566533;11131684;11570788;10936758;11285990;11356907;11888471;11369000
+11511905;11562352;11826821;11853393;11692202;11905824;11828204;12333208;12224748;11925611;11649811;11783037;11540920;11550007;11754571;11337978;11672593;11339921;12039791;11542101;11656269;11411539;11926692;11517522;11512292;11165564;11959625;11784667;11369777;12102409
+11942040;12382850;11675477;12016374;12034900;12083524;12433558;11911751;12256126;12246437;12311641;11997896;11658662;12320688;11931038;12284519;12275250;11643984;12001974;11881772;11748895;11773703;12216907;12316099;11596903;12210615;12285449;11793681;11982585;12222217
+11989649;13049061;12382717;12526654;12286781;12284937;12618351;12294586;12222126;12622748;12444785;12930611;12326917;12116604;12153834;12583642;12201335;12260117;12100631;13060400;12100360;12523845;11960220;12608349;12304482;12111010;12191014;11978935;12011358;12587228
+13127028;12842189;13018418;12493466;12729371;12767996;12947881;12651872;12201935;12551298;12927713;12373404;12356391;12770328;12731003;12619248;12527631;12639246;13149718;12856335;12418420;12938733;12795918;12769556;12991604;12752483;13108057;12621732;12846644;13108208
+13653840;12668350;13187410;13509652;13456850;13141882;12885860;13216737;12457825;12418208;12632281;13083641;13645813;12570431;13159216;12650545;13285119;12994879;13104992;12427917;13426431;13072838;12673659;12871741;12880838;12808949;13201155;12732703;13261381;12709797
+13134849;13393585;13143373;13313450;13814596;13292451;13170425;13450333;13881424;12968547;13254086;13366322;13594622;13115568;13612015;13234739;13188449;13525719;13347986;13370279;14144641;14038787;13469140;13406178;13562950;13033570;13171466;13195413;13941649;13822219
+13606143;13489809;13894680;14059425;13291958;13201353;13552829;13250547;13368725;13672498;13779977;14023296;13929004;13802540;13930076;13769286;14133507;13402319;13892603;13972406;13626350;13530785;13816928;14029507;13794593;14224512;13936466;13937088;14555248;13853727
+13811767;14214381;14415719;13918000;13436325;14359613;13890763;14798380;14222577;14371761;14206773;14311699;14271498;13963467;13773960;13646247;13932311;14260940;14057587;14222984;14059808;14241147;14008144;14205803;13933164;14433771;14500923;14212261;13890021;14224031
+14262827;14396659;14383393;14331869;14286137;14342157;14461521;13762628;14156566;14267805;14621743;13909934;14108255;14780473;14138874;14585284;14551506;13987270;14049029;14837077;14600439;14339050;14729600;14408754;14777321;14049551;14346136;14063506;14781724;14424658
+14750651;14704778;15024950;15484646;15116388;14462765;14499967;14721444;14845768;14937609;14848802;14592755;14666790;14375854;14842456;15198516;14711913;15280245;15448606;15216474;14994417;14623823;15217242;14733888;14678337;14862299;14371118;14608275;14911933;14655335
+15038841;14544264;15341997;15506971;15252127;14976141;15149842;14753439;14620766;15447196;14800296;15175587;14770909;14872437;15051739;15095695;15470744;15239234;14793585;15384107;15168691;15407842;14796535;15562504;15494409;15246068;15421182;15021794;15186017;14836156
+15648534;15318674;15052028;15830839;15249645;15302418;16545696;15117551;15158330;15722020;15367579;15509658;15300005;15519987;15737202;15237519;16080118;15372911;15205120;15333764;15492092;15218794;15582789;15386362;15579700;15471336;15935348;15057088;15196702;15274053
+16053377;15425229;15523340;15654518;15840242;15978594;15484951;15697359;15795029;15590504;15557325;15658906;15466476;15607183;15766074;16408186;15732195;15391063;15632848;15968146;16209560;16317782;15744202;15956649;16041154;16284021;15774507;16302996;15528782;15361553
+16108540;16097908;16351656;16402885;16507941;16479123;15220125;16361198;15934959;15918365;16072018;15923844;15933120;16035000;15759378;16362023;15874962;15773522;15651342;16367858;15898124;16508933;15842143;15470240;15726382;16931869;16103672;16545590;15947914;16456902
+16395120;16442213;16500705;17113316;16219049;16722106;16506401;16136123;16206200;16381623;16697382;16193482;16230453;16225923;16182176;16048372;16294745;16937256;16838952;16425028;16158353;16719865;16561833;16604326;16342892;16323594;16176320;16352346;16536818;16337276
+17261737;16771304;16832814;16552032;17248869;17553193;16550998;17729278;16138066;16742502;17250295;16994893;16139094;17524660;16774879;16633279;16910773;17182816;17042762;17745976;16758801;17245264;16465635;16689325;17417658;17349153;17161384;16836003;16781166;17004945
+16999282;17093206;17841472;17268598;17001513;17076269;17309776;16721280;16847137;17135191;17183895;17261638;17497257;17107191;17032173;17872790;16962045;16744307;17138278;17576216;17294421;17642361;16919956;17105237;17403210;17123161;17536029;17194839;16895792;17119390
+17261367;17702129;17223881;17625177;16971385;17318022;17412076;17622608;17184529;17747250;17123576;17275443;17762988;17661789;17389675;16937208;17408809;17796248;17944498;17510737;17378867;17003421;18150767;17786613;17663852;17273027;17521301;17841968;17480369;17125905
+18191289;18056453;17777468;18583605;17779289;17987225;18185332;17739849;17280860;17819865;18065626;18040893;17684105;17924544;18189062;18604443;17860777;17768665;17892438;17482685;17917665;17141186;17366023;17537419;17667082;18208210;17823687;17582732;18175102;17972194
+18187745;18669095;18912701;18065072;18116432;18352242;17956669;17617894;18065447;17819116;18175121;18216822;18514834;18731576;17654800;17788690;18253520;18747665;17932630;18099887;18010469;18528332;18053593;18757969;17593685;17887967;18788344;17912013;18340299;18707605
+18598692;17802766;18575454;18231011;18485928;18241239;19069787;18922567;19229257;18344247;18387170;18990498;18735398;18222616;19020183;19234071;18842977;19114234;18183756;18313429;18206959;19112758;18482957;18652519;18297634;18928565;18812276;18961017;17984529;18936308
+18565993;18370400;19226511;19103150;19509462;19029223;18650874;18360516;19522202;19077595;19451243;19209140;19054677;18663914;18666508;18816810;18384667;19067640;19117125;18853502;18600152;18938573;19232847;18899105;19183739;18480014;19054847;18889994;19013183;18292126
+18844483;18664631;19483659;19872084;19089017;19616295;19694749;19667192;18648103;18972967;19494073;19364400;19336384;19261968;19063241;18854741;19508677;19177589;19246774;19797056;18684135;18503051;19407414;19573566;19192533;18519089;19322717;19101595;19247490;19733465
+19627877;19587970;19464268;19687122;20098564;20236572;19706436;19984769;19198053;19268481;19214375;19873699;19977742;19834704;19456563;19182569;19948812;19766407;20004530;19413025;19987504;19842481;19089722;19392022;19418653;19560960;20166439;19995047;19269190;19851913
+19785994;20753901;20741867;20579590;19023716;20309742;20070926;20572611;19412802;20188393;19689028;19615346;19712604;20386875;19781496;19489527;19774732;19614950;19646190;19562586;19893850;20046918;19913949;20686593;20212559;19762171;19926963;19489088;20151757;19891380
+20246341;20645547;20589849;20529221;19967356;20618682;20876694;20032458;19974064;20599743;20591587;19901733;20382850;20517060;20647162;20622824;20031862;20422141;20213164;20349289;20218022;20237509;19904801;19795006;20571097;20450731;20753831;20127091;20183450;21302257
+21287819;20618548;20461699;20574868;20578554;20401931;20510822;20757882;20913996;20649601;21035622;20756596;20515677;20567528;20709404;20674035;20389942;19847453;20834371;20524539;20334530;20054003;20593492;20736531;20776006;20608813;20379463;20154425;20626083;20450469
+21376070;20888662;20654806;21170751;20890223;21652227;20804504;21091722;21338010;21125587;20891922;20842756;20929223;21067982;21601169;20945332;20584919;21136763;20699583;20974317;21184996;20733699;21366258;21218672;20131232;20656524;20347443;21098383;20289950;21268474
+21419195;21229916;21157495;21498267;21406278;21126042;21764673;21458117;22251670;20526503;21323072;22116836;21245430;20783492;21854692;21127138;21227062;20781245;21050868;21315884;20863924;21850031;21161752;20947974;21303204;21123014;21111241;21022739;20546803;21901316
+21270839;20840723;21564008;21655105;21684231;22522750;23000188;20948078;21386491;22054740;21124150;20930692;21479539;21148375;22208134;21658864;21699153;22037921;21402145;21420139;21648825;21452090;21663952;21176714;20913272;21200970;21575106;21760947;21787388;21680361
+21879606;22884691;22164930;22842707;21907229;22608529;21860466;21766882;21565890;21863851;21830967;22018031;21764948;21750949;21551080;22000522;22632461;21722692;21981043;21788088;21901699;21998727;22042241;22059163;22232309;22550695;22562321;22165686;22503462;22171718
+22066853;22174493;21749586;22339113;23047528;22546513;22574397;22251257;22137676;22202602;22200247;22148998;21534043;21809478;21920654;22367421;22229272;22542209;22109918;22253760;22421140;22414309;22602051;22429837;22227333;22615127;21911791;22565441;22115284;22685487
+22421545;22804651;22910827;23188095;22490249;22861850;22787937;22648786;22822924;22500898;22056202;22566466;23120559;22607202;22798172;23505245;23001566;23402815;23013880;23129363;22621838;22102969;22276658;22584393;22815203;22990641;22358873;23214495;22224711;22753268
+22626501;23479076;22948646;23007791;22908408;23306942;22913104;22141056;23761541;23192314;22742332;23163128;22712482;23130043;22224985;22793057;22919193;22239713;22496442;22983798;23749552;23493044;23366939;22456039;23154364;22763365;22797090;22596782;23349943;22874350
+23462941;23551714;23129413;23035400;22810042;23229345;23274653;24059385;24130893;23078690;23094101;23069633;23199475;23926726;23525807;23537791;23730804;23441370;23960642;23639446;24058208;23009903;23938362;23503368;23975444;24290536;24330333;23660423;23258322;23514008
+23238594;23426296;24085104;23391675;23893902;24189574;23088487;23649617;23732798;23658013;24151329;23685265;24339233;23233248;24107953;24096801;23776910;23478110;23359981;23511493;24031903;24114692;24319289;24327544;24323777;23747519;24177704;23525378;23605012;24159757
+23531660;24170077;24262045;23877341;24120316;24368881;23753505;24365582;23676426;24856955;24431579;24332687;23930408;24264596;24154371;23535881;23501123;23594344;24315984;23812075;24685568;23580262;23575816;23747298;24271643;25035446;23723431;24200936;24501529;24107934
+24430431;23545092;24306027;23636389;24874248;24606850;24111588;24440154;24503067;24354739;24405066;25013325;24065858;24573853;24234184;24087460;24551538;24689056;24431595;24224674;24767067;25312291;24800388;23529213;23827802;23948395;23917423;24445437;24271389;24347367
+24237084;24129554;24540050;24210662;25243295;24792560;25602208;25071268;24287989;24379797;24586365;24956985;24320118;23777907;24060585;24770422;25252435;25281051;24691197;24721646;24361829;24952062;25138373;25018379;24699371;24598434;24216445;24368869;24926077;24494972
+24953289;25014076;24477076;25669166;25319058;25222280;24970702;24996302;24652626;25012382;25272497;25444140;25390664;25524161;25190105;24707252;25626230;25175566;25095578;26052362;24435628;24951278;24948844;25119654;25000834;24651317;24205182;25015172;24824692;25097040
+25350773;25854477;25496305;25708623;25962014;25905984;24884585;25943657;25949137;25418477;26114407;25414740;26334252;25692748;26297060;25906170;26234849;25883408;25355353;25240080;25979662;25248407;25098194;25239437;25267952;26022994;25855499;25564593;25739314;25530076
+25516170;26149819;24801566;26388710;26163454;25696148;25749311;25470971;25637715;25904361;25430123;26545932;26026618;25864401;26946728;25575491;26355942;26017868;25358033;25809353;26302256;25857806;26397030;25807156;26758028;25511154;25789493;25466606;26129611;26344808
+26164908;25441036;26359416;25864054;25576206;26202940;25279281;26041830;25245004;25651461;25947504;25379451;25859493;25979114;26209578;26315515;26520261;26288643;25564479;25786499;25941590;26026384;25401823;26417410;26027815;25929065;25953020;26380398;26096537;25721410
+26274052;25825664;25899166;26458657;25943026;26495538;26623405;27171665;27018088;26904008;25609019;26300999;26646097;26528540;26516567;26153533;27709938;27290253;27118931;26600698;26784523;26938804;26383687;26765395;26173329;26364358;27696785;26853144;26759974;26207212
+26801992;26654017;26141084;26740434;26655890;26569773;26886515;27067606;27011287;26925411;26718389;27123483;26565915;26459889;26690737;27155124;26841789;27636476;26832148;26209815;27470282;27465924;27252729;26640595;27143638;26099537;26448732;27136903;26688255;26357455
+27219092;27119309;27477463;27030167;27916724;27400143;27497461;27638915;26870919;26794028;27429690;27134948;26505170;27079520;27404178;27165655;27004504;26961670;27416940;27293393;26904341;26229421;27636095;26882474;27245799;27368094;26366535;26638974;27124342;27519297

thesis/src/performance/perf-3.csv

@@ -0,0 +1,50 @@
+11437553;12137288;11705973;11537837;11461139;11571642;11701964;11450287;11834551;11375463;11610546;11299384;11145456;11730529;11972747;11874788;11897502;11221133;11344952;11289504;11980612;11604785;11504719;11530380;11226421;11531160;11329030;11852313;11674769;11444494
+14052111;13837816;13712043;14281615;14470630;13896089;14591464;14230315;14021490;13961474;14399542;14621763;14635017;14460470;14763266;14216498;14278158;14626700;14582254;14175738;14438316;14187962;14138766;14039924;14952331;14172821;14599146;14835293;14374682;14200464
+17180853;16873828;17011415;17355560;16830614;16936990;17964549;17074857;17280515;17191863;16955797;17453460;16955947;16579659;17330871;16592011;16405319;16557464;17039814;17358874;17151432;17186490;16937910;17036960;17280212;16685078;17172111;17030979;16615134;16789240
+19559451;19984383;19635217;19407266;19659554;19931410;19880672;19397317;19969575;19421805;19686767;19151131;19799484;19897725;19518080;20147758;19439328;19408539;19417023;19211726;19635145;20026704;20036301;19594486;19359381;19508690;19531626;20538111;20122376;20501600
+22673304;22863539;22522811;23175153;22944064;22974694;22554501;23137800;23061091;22917032;22392427;22446752;22150139;23130666;22584358;24296681;22297563;23217412;22190787;22827017;22514323;22286831;23013738;22909135;22066134;22109580;22461178;22215465;22465566;22518709
+24633079;25499957;24937357;25002964;24940682;25930587;24968254;25745477;25071175;24949520;24693835;25110131;25243647;25021367;24826671;25022330;25069630;24725314;25438013;25142001;24575003;26924579;25072195;24960960;25134295;25299685;25030985;24853301;24654746;25053348
+28130121;27484651;27717641;27720268;27719094;27850480;27821792;27566949;27564944;27422129;27966131;27510378;30901409;27467031;27666943;28069777;27371489;27533772;27648705;27978071;27329076;27794244;28271839;27735350;27946159;28004462;27631411;27946079;28357744;28346632
+31916398;30874042;30560926;30122858;31020925;30691068;30620089;30693031;30123961;30588008;30933847;30630911;30825789;30592224;30957672;30396235;31646754;30695544;30152924;30236937;31144774;30175918;30133956;31103111;30702616;30250280;30994671;30135969;35398228;30146549
+33063722;32608798;33106303;32687080;32871667;33156831;33353378;33551812;33303542;33307269;34485338;33969591;33520282;33113856;33198198;33258404;33073678;32972502;33033731;32939778;33513197;33874386;33941565;33179903;32790299;33128083;32881665;32936652;32956900;32976960
+35733239;36589177;36119425;35501641;35679444;35479347;35264081;35347661;35915019;35835455;36195341;35658924;36278979;36103953;36223334;35753275;35600646;36509577;37795394;35443576;35743815;36194025;36416194;35971185;35369361;35858364;35442951;35755757;36375254;35791305
+38455195;40675369;38593493;38820672;38832175;38733724;38568865;39371447;38565569;38318200;38532215;38642398;38691582;39053292;39167543;38712963;38749214;38704296;38358918;38514779;38743210;38531102;38450204;38016065;38218335;38061152;38396011;38266387;38714844;39130608
+41260687;41116738;42772770;41332754;41453941;40879423;41355168;41664365;41384434;41680757;41020370;41345069;41191159;41797288;41554951;41011081;41525284;41129297;43168642;43124056;42570976;41318925;41287713;41467169;41616399;43784852;41358830;41384780;41539400;41331547
+43887910;43786084;43796894;44328331;43863654;43562611;44375322;43685027;44487118;45235525;44454054;44404147;43700476;43387921;44037719;44612981;43646421;44076363;43721147;44268212;43635151;43996537;43629377;43873448;44448289;44869814;45086122;43906721;43866314;43957600
+47081329;46615648;46317242;46423997;49226246;46928152;46808214;46394610;46678108;47322454;47181998;46318663;46635283;46699489;46723866;46911076;47165589;46265023;46530316;46763761;46930163;47184414;46982684;46927344;46551657;46314521;46543213;46804327;46619260;46449491
+49360829;49080216;49606433;49209497;49348115;49038846;49306092;49427658;49762796;49375115;49305872;49387830;49570213;49321764;49356981;49098692;49459639;49747156;49663033;49234154;49096528;49028184;50306755;49543880;49199785;49355885;49388328;48845569;49220413;49184504
+51791483;52024023;52253892;51829105;51764530;53598416;52265276;51778407;53413116;51938787;51925591;52400478;52263914;52135906;51953143;52180396;51803613;52839647;52556948;52973013;52037665;52590693;54354097;52489077;51989912;51911949;52414783;51897533;52177311;51613724
+54520289;56763769;54800159;55804943;55563116;54750403;54456788;54700199;54666321;54888452;54830589;54565879;54575947;54934961;54984325;54888531;55045554;54423833;55031497;55065062;55752029;54929008;54458649;54832572;55379218;54198676;54562030;54571487;55155616;55041036
+57403491;61360128;60245045;60131735;60578760;59604945;57957129;57441702;60410924;61600081;61410914;57923132;56944230;57829331;57200029;57451470;57297742;57412694;58289946;57219235;57230231;57202057;57474173;57310045;58022873;60322257;57861670;57238716;57883773;58071766
+60543173;60673795;59943981;61169583;61514610;59962490;60188647;60125735;59875760;60634589;59756351;59642771;60559092;60368753;59993208;59989019;60400469;60776701;60728438;60741021;60013355;60294244;60020348;60369511;60048061;61895269;61545276;60353639;60072075;62974103
+63488988;62519937;66149160;63213949;62802343;66779940;63018620;62609180;64066214;62967290;62680236;63177045;63546540;66189017;62640037;65891321;63143110;62630519;62877817;62573208;62504666;62023286;62924488;63180812;64357116;62659373;65953339;62570373;63798725;62384852
+66052841;65917870;65459074;65569088;65579084;69305787;65232304;66010482;66095967;65516122;69488350;69094077;65468610;65257836;65774861;69780301;67196438;65366252;69208777;65280334;70427422;70521213;66344530;68209795;66555388;65032023;65587407;65550798;65634437;65291073
+68501387;67832602;68153413;68002713;68116143;67896698;68173479;69902754;68333661;67688274;68299466;68620425;68016638;67808416;69448446;68217935;68207086;67859955;68122242;68285167;71131080;68465664;68914793;69081301;68034391;68059027;72513045;68443511;68351152;68550737
+70878105;71087576;71047432;70652237;71406754;70828706;71951278;70846993;77804496;72334806;70716800;70657838;71129910;70542802;13929749;70969078;70786134;71058670;71002121;70808496;72302503;70595305;71111111;70725626;71135959;71274717;70933729;71379349;70909141;70957324
+73617504;73809576;73454560;73449059;73222250;74701359;73250284;73544693;73382952;73301792;73828901;73430832;73607456;73278678;73889030;73419952;74223506;73333783;78359227;77982976;73177831;73643270;73844298;74274139;74607836;73749279;74388880;73574941;73438093;74146772
+79041965;76523030;80680800;76629641;76074887;76863821;76306996;76602045;76280307;76051541;76838863;78017389;76434721;76412038;79171128;78112522;77423541;76164839;75988467;76106275;75944594;75881102;76556294;78392596;76493292;76886402;76269179;76939505;76119800;76739961
+78910282;80878046;79312839;79698905;78823353;78698642;79390488;78927934;79679146;79027477;79353466;79549035;79125105;79162686;79342054;78882566;78616572;79392060;78897985;79300758;79000202;82011014;78897383;78629624;79059275;79558149;78750439;79127241;79545695;78607877
+81698198;81573605;81910281;81882061;81815344;82059455;81529336;82490099;81801832;81704734;87907268;81392551;81965241;81932209;81701017;81436916;83201723;82253364;81395674;81845161;81757911;81968275;87384319;81704230;83904413;81715952;81580428;83449244;82034788;81417037
+84138344;84317811;83946526;84911933;84799757;89920444;84897932;84399245;84377436;84672734;84252602;83950232;85081020;84661936;84857778;84355482;84479027;84550480;84492742;84378262;84361718;89948016;85073732;84449360;84469807;83948242;84360447;84669888;85018996;85072991
+87088205;87007042;87208915;91964769;87832598;86912434;87452250;87269412;87505275;86657532;87335541;87138874;87179747;87299094;89635265;88185575;86935936;87690891;87265814;89485912;88536278;87124248;87155912;86726940;87473226;87323415;86931771;90220263;87226452;86811078
+89964990;90485081;91126193;89454746;90217168;90451379;90002450;89488081;91905316;91897480;94958011;93163466;90223382;90264902;90560531;90640420;90042245;89582606;91379488;96286627;90112726;89809288;89784838;90572518;90932341;90046461;90242333;90069576;92937597;95463352
+92198119;92678169;92719411;92484921;98576707;92895039;92532575;92250403;92543948;92752510;92550961;96821055;92963694;93913591;92913877;92714477;93800305;92437457;92631922;97139543;94559271;92620280;92261362;92156705;92375176;92250764;92515021;92334167;93278515;92789330
+95306679;102224623;100803820;94847204;95229627;94872917;95673893;95456479;95537320;95042066;95049909;95089548;96125924;95241239;94927256;96328468;95749526;95591606;95767733;95438207;94923178;94979457;95936239;94700755;95175536;95051642;95164395;94948626;95360677;95142665
+97825494;97995314;97830597;98410006;97892946;98565410;99683413;97844186;97596816;97658969;98088616;98206421;97928358;98491839;98613813;98682460;98103920;97971401;98772227;98208426;97938935;97438572;97575451;98192362;98171485;98276141;97779043;100756784;98510874;97360856
+100177976;100863650;101059730;100747751;100671157;100442295;102518422;100120780;100911331;100318114;102784093;100326714;106685654;100436805;100842631;100467237;101138824;100056593;101416796;100706017;100503425;100331192;101535407;100518940;100701003;101046269;100762087;100004494;100392285;99949598
+103659664;103703692;103505039;103464379;107885471;103119869;103042567;103255645;103725726;103274191;106699424;102669005;103579170;102766820;104859222;103321005;105097135;103660200;103103627;106373921;103517530;103156918;102955869;103518802;104720963;102579912;103115023;103358668;103682441;103468790
+106393849;105882425;106216161;107961320;106368726;105736686;105543494;105889340;106280985;106464075;106646517;106295524;106534880;106463920;107444505;106267764;105890607;106679806;106030352;105964845;105862502;106452205;106124817;105964244;106280854;106365271;107278722;105833152;106567844;106261335
+109269869;108837464;108690398;108374735;108849334;108075096;108793970;115599432;110294210;108664137;109038898;108971153;108852591;108591836;108626777;108139479;109052247;108972815;109499901;108570640;108957286;108452922;113194421;108495450;109000384;109055199;108533313;108576932;108551344;108811360
+112161635;111592570;111830724;111956071;111365732;111008363;111979520;111581069;111002305;111382688;111775398;111224502;111766086;111136272;112114437;111367647;111121692;111139533;112168077;111969706;111692782;111302519;111560999;111548343;111686699;111451721;111290094;111694625;111393493;111536231
+113987748;114823012;114668634;114195931;114514503;113754185;114194838;114041197;114527409;113979236;114393656;113870843;113995622;115648136;115465456;113882070;114829232;114145665;114579659;114416124;114350555;117028233;114255345;115912166;122138775;115464873;119968797;119368027;114217952;114088870
+122281891;116188131;123831535;120096723;116806838;116520957;116816975;116480627;117563556;117073632;117131634;116768275;117319565;117927866;117274865;116783454;117259399;116450129;116961050;117411701;117157863;116614225;116620683;116915088;116786006;117888700;117065685;116408463;116499999;116434329
+120671303;119979013;121068561;119735830;119761537;118959981;119817720;118852055;122775025;120304582;123551741;120185550;119512252;119301499;119470529;120244567;119537389;121244263;119595263;120259791;120104053;119119766;120140118;118894700;119369498;119154391;119669806;119501218;119393583;119876822
+124588826;125298956;122851122;121624281;122237231;123479795;122845960;122262533;122248976;121773159;122476146;122540432;122579059;122035253;122249769;121811048;121914444;121915561;122731008;123818893;122019586;122439793;121941475;121906620;122718561;122210181;122642623;122291676;127732069;121785173
+124751022;126168468;124675648;125099334;125016642;125104474;125047253;128731621;125276912;125304085;130987950;124932750;124865513;128454368;126041389;124760871;125228115;124841077;125350303;124675310;124968912;124484638;126466476;124992822;124888686;124838209;125030169;124692691;124644911;126494173
+128090412;127540404;128333074;127477139;128083354;127879288;127978521;127652572;127484846;127469334;127562730;127995296;127715547;127674675;128658003;127711237;127549564;127553205;127516346;127691128;127899502;127562564;127939499;127660526;128278953;127031534;127626006;126978338;127763640;126990300
+130521998;129971811;131005082;130752424;131420143;130728480;130364639;130017042;129991445;131060302;130581466;129792603;130421211;130121477;129854093;130708886;130070400;130276734;131224078;130520572;129616847;130693720;130305798;130290623;129817319;133300358;130981772;130908105;130157302;130318357
+132921722;132690700;136041971;132620017;136884086;132726826;133381245;136449684;132851956;135201007;133494545;132688777;133587585;132593265;133124373;133102915;132851296;133363139;133588787;133018724;133768524;133045656;133141910;132710238;133437916;133414394;133249836;132923109;133280805;132724112
+135693784;134918568;135865296;135185920;135435674;135137053;136169330;135375265;136131092;135284690;135676710;136040274;136133191;135762639;136469504;136490275;138371907;136326994;142122876;135062735;135637534;135253187;136520163;135199840;135566064;135461397;137804905;135693977;135519648;135959504
+138320225;139347612;139673130;144319460;139359929;138302501;138575901;139022991;138720982;138644756;138778494;138495324;139391044;138770042;139372174;138462575;138810657;138728456;138821644;138372360;138841583;139172984;139979859;139307752;138892870;140890737;143763427;138783397;138905511;137853849
+140941339;140522473;140647083;141018932;141341488;140649678;140732198;140825239;141908935;140976646;145911632;145443610;141400869;151699717;150322036;142178208;141074731;147332023;141083139;142282576;141301386;142784010;140988140;142091094;140815764;140951936;141218633;141008501;142237955;141411392
+144688882;144428567;145446474;143924448;144131789;143830104;150076733;158397578;145531892;143757389;143596411;143203293;144359936;150219644;145122741;144091119;143725782;143768652;143762671;143538063;143773341;143974804;153742275;144117976;144011754;143543591;156212968;143708100;145168034;143216733

thesis/src/performance/perf-4.csv

@@ -0,0 +1,50 @@
+11991752;11662537;11463378;11852468;11206774;11826767;12029693;11642055;11809993;11439769;12055023;11727250;12413903;12313005;11517920;11797774;12767532;11596713;11513872;12182818;11637291;11987476;11542735;11959600;11639164;11835267;12152658;12376164;11616427;11401919
+13252705;14236318;13790236;14697879;13112401;13657877;13516679;13505860;14992202;13269414;13639707;13298150;13338970;13351622;14429821;13063400;13263510;13427341;13451679;13605448;13201368;13288739;13270883;13371309;13304498;13550408;13388502;13331521;13786869;13244918
+15631533;15557938;15034976;14966362;15448203;15502660;14894921;15022410;15239131;15344056;15245513;16788428;14606876;16325854;15170757;15066864;15044469;14920196;14972128;14932138;15378069;15413677;15515517;15438927;15832146;15775324;15461428;15028073;15263573;15080504
+16912332;16703163;16700517;16647022;17023979;16937801;17009170;17338744;17151237;16920615;17282479;20078109;16623473;16890894;17134891;19672636;16661235;16554358;16782491;16909007;16956092;17171137;17076262;17136871;17668638;16993400;16751788;19667932;17021344;17094086
+19215666;19164797;18397699;18807649;18566136;19215183;18733272;18797779;18852745;18291258;18668413;19089145;18606762;18604157;18550793;18531434;18371772;18561141;18982925;19161843;21505769;19096826;18266835;18546190;18726881;18554554;18795655;18616395;18602377;18794091
+20554526;20222738;20258429;20339157;20939867;20674098;20794973;20723503;21287623;20546987;20559611;20504734;20163358;20275897;20351224;20285506;20797656;20835026;20487838;20347875;20383743;20197310;20792330;20550167;20851596;20609652;20599813;20780065;20930217;20619420
+22281372;22459890;22198940;21988399;22692701;22467172;22541687;22038937;22045639;22611953;22039397;22499734;22256420;22262148;22372543;22479802;22323276;22443570;22034261;22073508;21955097;22446455;22179493;22496442;25227528;22280508;22138030;22132400;22133181;22379700
+23737349;24181954;23613335;24170682;23864124;23889644;23949150;24359861;23734689;24064393;24553905;24128194;25096813;24120929;24187168;24529064;24156208;24249038;29326920;24199943;29457555;23582239;24900272;24055508;24211302;25001882;24267320;24662729;23974698;25125611
+25932063;25865423;26053340;25771992;27251497;25968235;25873777;25425532;25539936;26031213;25500315;26230480;27258664;25651740;25839156;26133820;26158688;25614887;25871629;26280272;25602080;25945068;26602630;25725610;25929458;26161870;25748922;26065852;26086080;27011353
+27655940;27705396;27895777;28003718;27734373;27508490;27168116;27714123;27665454;27903187;27664662;27342604;27744236;27936089;27727161;27640152;28376296;27467526;28949474;27746758;32641239;27236453;27352387;27598407;27436752;27487570;27580049;27910923;27715663;27586150
+29266148;29074931;30671002;29125708;29649519;29798799;30095156;29433476;28876951;29405681;29309331;29614918;30780726;29317135;29787943;29224123;30093688;29817761;29906463;30494038;34020568;29470742;29412248;29433228;30639137;31467901;29334364;29600543;29411222;29323292
+33000655;31888055;31535349;30799565;31378283;31237768;31351851;31103626;30731392;31076983;31246633;30946638;31421469;31289986;31696518;31142037;31134259;30631120;30883292;30939991;30521446;30885123;31125060;30784828;30944299;31408260;31067660;31253398;31062526;30872255
+33163006;33164360;33291365;32651819;32645126;33446867;33515719;32432640;32572582;32724608;32444523;34104496;32883388;33383330;32685681;33031593;33779740;32809664;32563931;32585392;32782085;32745633;33467287;33361079;32516836;32971961;33100633;32724840;32612591;33217529
+34800792;34578740;34435731;34921085;34641079;34419837;35139631;34813380;35147413;35215866;34921922;35419509;34291622;35660127;35133032;34776105;34802919;34607988;35159923;34710366;34908583;35679543;34439758;34655871;34204248;35305181;35873889;34241259;34520993;34647069
+36146918;37709119;36414077;39808115;36661157;36509422;36796871;36440306;36414004;36307868;36589737;44952809;36372021;37156368;39532296;36732022;38844536;36224361;36315136;36667990;35968539;35948072;36382604;36281146;36932697;37180549;36435718;38765553;36237992;37632938
+38243105;37912771;37999209;38667159;38257885;38905352;42631595;37919646;37694143;37799227;41668357;38081557;40770970;38445593;38823889;38015785;38110199;37875460;39209747;37959603;38537830;38453024;38152719;38242354;38221844;38097072;39114299;38866626;38027853;38054214
+40608449;39749933;39798342;41051853;39863213;40586119;40009442;39928609;39921111;39539959;39720571;40336179;39904338;39983402;39750235;39818741;40726066;40121301;39833078;39802528;40264568;40633096;40921404;40159371;40131496;44850528;39978718;39637672;40067169;39951163
+41586394;42093099;41671888;41959347;41799866;42132695;41821418;42070973;43086400;41365280;41448372;41473810;42823097;41183096;42950071;42183994;41749384;41989441;41542901;41497112;41988003;41488574;41442334;41656581;42068211;42697866;42505532;41365763;41577261;41567285
+44181668;43508759;43189198;43382274;43366142;43292910;43439334;43561783;47628234;43066417;43563834;43693005;43670130;44085849;44211482;43131103;43804861;43526638;44317796;43842199;43291258;43972126;43175463;43626941;43684382;43308219;43517716;43756460;43179608;43261377
+44875247;45049996;45591569;45446538;44898813;45430194;45511273;45134039;44938105;45919294;46261589;45268957;45423392;44935246;45667201;44745118;45296018;45751944;45780900;46028240;45323207;45561524;45150803;45690362;45308278;45279422;44808526;45532412;45371760;45159637
+47216047;47267457;46809567;47268018;54110817;47133604;46744687;46691634;47026987;47791535;46808440;46765365;47108873;47440566;48904875;47182914;47222603;47089473;47455515;48312932;47018544;47156632;46907427;46919510;47138143;47406406;46982701;46939006;46922284;46698979
+48444744;48588955;48567422;49765301;49008709;48878845;48870662;57227571;49119092;48407217;48423980;48368691;48902660;51083560;50959338;48762742;49146061;48291258;49586853;48871956;48157026;48798172;49228686;48985356;49131469;49503592;48727972;48499117;48893776;48899004
+50160508;50865949;50339635;50141741;50589181;51008375;50406855;50426212;50406233;50975168;50659097;50222886;50263487;50087912;50591640;50637048;50710623;50095905;50328257;51146317;50324973;50481624;50281935;50459581;50909816;51513699;49872486;50875666;50270701;50756573
+52275587;52533329;52166414;52649855;52259445;55665698;61735900;52463913;53632375;52735991;54062471;52876765;51907761;53382906;52598825;52509798;52658337;53649934;62502548;54009694;52192169;52494697;52292058;58633315;53427466;52542425;52338831;52668952;53086725;52337827
+53638437;53935213;54664377;54032722;53991792;64429984;59810741;55173536;54420162;54916677;54279319;53917454;54004022;54294567;53967572;54394702;54270981;53660243;53877667;54436442;54015915;54555531;63175137;53976068;54112660;54215689;54086771;53748239;53994018;54206699
+56251175;56680125;56214983;55562104;55713908;56022487;55783092;55879208;56419035;56171977;55769423;55743533;56024328;55800200;55751317;55855066;56350970;56519429;55519293;56003545;55601443;55454718;55818696;56018263;55818164;56266376;56320792;55341496;55975949;56601056
+58516408;57321414;58116640;58468882;58062446;57293380;58067612;58086752;57819118;57816422;57471612;57447985;57677250;57229109;57685028;57782003;57600520;57873165;59280244;57847748;57772232;57896234;57524551;58318753;57290945;57517626;57597330;58554870;57396920;58828349
+59424327;59544681;59614196;59712858;59593055;59900393;59401353;59757084;59244137;59631741;59419858;59318813;60004405;59741684;59762495;59261829;59407674;59851745;59244889;59825785;59452487;59346853;59435634;59148165;59120632;59269500;60028283;59951696;59225875;59643806
+61487409;61665083;61230248;61297148;61443268;60863182;61334149;61005259;61973049;62868068;61443697;60958147;62415865;62319441;61218171;61680068;61466310;61606682;60610419;61007328;60733648;60946571;61022007;61354743;61392885;62605382;65893763;61962814;60798111;61452072
+63441265;63824379;63173968;63098218;63959722;63578601;62697428;64080104;63218720;64974131;62860323;62939587;63308383;63452524;62829252;62709947;62044069;62873456;62504319;63288512;63013157;63024318;62938391;62672343;62795903;63171874;62667393;63713937;63235687;63272732
+64234376;64731647;65341718;65502688;64776479;64194476;64882210;64644661;75375878;64938292;64923811;64350157;69649753;65079172;64178984;65116385;65472989;64934422;65764113;64516920;64972495;65038663;65076628;65094321;64617202;65040246;64203028;66072854;64186418;64861827
+66532452;66780765;66771847;66277140;66117209;66516840;66360407;68608503;66177870;66470230;68157910;66499856;65983398;65876313;68558394;66347260;67215396;69279473;68133858;67026590;66578955;66580910;66752743;72550246;66090276;66346704;67024219;66237481;68144816;66099297
+67788063;68137601;68267073;68601441;68751183;68306890;71861764;68460577;68182747;68239406;67834449;68389065;69790518;68128629;68491224;68546972;68102889;70115289;69135555;68528767;68264043;65534088;68579866;68626125;69562024;68325951;68403593;68050435;72033662;70016616
+70026963;70135995;69837205;69948252;70429203;70144701;70402381;70351342;69789440;70252203;70221668;70138257;70267940;70089270;70013322;70269660;69974958;69680114;70437370;69942203;70042207;69891171;71440428;70750632;70072916;69647960;69998030;69935228;70911053;71024874
+72247899;72216394;71748398;71981600;71831789;71595400;71791837;79429147;71686576;71564069;71837074;72121559;71613824;71415245;71584934;72394707;71670112;71810273;71489852;72038305;71180739;71741830;71745758;72344700;71957368;71934333;71839078;71906169;71947469;72193366
+74331839;74103827;73206144;73624695;74356215;73986407;73381742;73806949;73766512;77024158;74022139;73726490;73686997;74001734;73631825;73860489;75661487;73309207;73213392;73062749;73315339;73213151;73943734;73866132;73701338;73518252;77160275;75387391;77207747;73596944
+75120809;75268941;79779276;80383084;76133930;75203763;75453084;75497654;75497804;75457415;76756006;75334968;75608758;74785338;77410858;75719439;76493177;75106892;75144916;75343832;75286715;75378745;74878252;76022339;75438785;77711298;74826424;75037235;75622491;74985700
+77362718;77300589;77624017;77674535;77827149;77169791;76701845;77603283;78120969;78429270;77785317;76792259;77002197;76898285;77351996;78477321;76599284;77187205;76598121;77543648;77769184;76894227;77561921;77229427;77151676;77233746;77011803;76731641;76751326;84233509
+79303763;79491547;78943575;79638412;78637768;79230299;79075973;78791546;78670832;84134371;78827525;78802200;78575705;79148105;78644659;79182116;79050918;79452269;79199382;79208305;79095744;78402732;78777985;78899334;78631929;78679799;78872679;79267007;78598055;78794959
+80897167;80452838;80730574;80785807;80483141;80583719;80727084;80237400;80626867;80982788;80649200;80421463;80652046;80832708;80383658;81142766;80506488;80310044;80403470;80717713;80793645;82103507;80613515;80515416;81158324;80403468;80526547;84847498;80992558;80932043
+83067882;82476004;89476805;82858000;84181452;82020001;82074595;82560586;82646738;82687865;82113430;82729040;82678009;82686017;82439744;82569450;82523715;82633205;82316106;88791776;83289026;82159748;82373199;82233108;81895130;82472382;82197992;82763536;83112453;84346521
+84512715;90615380;84245642;84364239;89173816;85740944;83956417;84170164;84504440;84312263;84299912;92272935;84477402;84015782;84136456;84753357;84774618;84894419;83985306;91726952;84701616;84699440;83785557;91937309;84169645;83751972;84132591;84537602;84394710;84339809
+86044226;85992306;86462305;86146365;86229834;85826072;85768889;86148811;85865184;86109943;85931509;86704213;85857574;85678645;85725623;85772761;85710063;85970463;85979581;85395101;85933348;86170625;85704918;85390121;85774681;85381893;85803244;85760072;86346947;85959763
+86702559;87313900;87881467;88310189;92527407;87516942;87791610;88444903;87386815;87347462;87649859;88295545;88368694;87469516;87796957;87992488;87534226;87685388;87981719;87245150;88119191;87772279;87589938;87881587;87971280;87587191;87466209;87648575;89057251;87554198
+88924359;89014914;91178270;89334165;89125210;89059989;89824578;89845010;91063681;89362398;89473754;89696872;89408245;89414717;89571583;89608775;89328615;89878145;89199632;89132464;89426661;89499934;89791237;89754283;89444613;89182663;89990807;89744814;89875654;89333129
+90943786;91251061;91705715;91046551;91099069;91140168;91221753;91039669;97214624;91221199;91131368;90934316;91432858;91453232;92144140;91451034;91832102;91431745;91679343;90889223;91422180;90962979;93149536;91892474;90957064;91783300;91718036;91345624;91050391;91383521
+92815971;95669183;93097565;92873260;93029734;93009548;92854980;96576517;92887523;93573291;94003113;92766844;93056509;92977489;98110781;93650482;92935272;93159298;93159784;93155672;93544232;93175352;93247460;92806077;92531217;93793156;92634290;92729917;93205099;92830116
+95728490;96466662;94724755;94487421;94918826;95022630;95481265;94580232;94732412;94575332;95030826;95560589;95173362;94324383;94687307;94054696;94254046;95569201;94613673;94776201;94466991;95090195;94620189;94636320;94348557;94634383;95625575;94865152;94995423;94445926
+96331303;96607162;96853043;96462259;96776934;96304575;96516575;96239461;96845504;97637686;96535543;96705375;96033818;97336163;96473726;96492757;95903636;96274049;96336297;97466373;99079357;96433460;97215031;96507153;97084894;96796513;101281352;96520733;98162289;96704387
+97915162;97351840;97948510;97718809;98456091;98347874;98282431;98329761;98342433;98065233;98304711;100588957;99648323;97900491;98208683;98251062;97939208;98294813;98428392;98493329;98593246;101496978;98083376;98560131;104358638;98433476;98566993;99851942;98565428;98171815

thesis/src/performance/stat.csv

@@ -0,0 +1,51 @@
+Cycles;Baseline Avg;Baseline SD;Intercept Avg;Intercept SD;Stderr Avg;Stderr SD;File Avg;File SD
+100;394522;59714;10427113;462988;11575964;253473;11831990;348689
+200;684480;89390;10728908;272181;14325139;305707;13554674;460807
+300;1004806;131581;10962041;312386;17027194;323923;15330088;441731
+400;1304127;83545;11372661;270890;19712621;347909;17249057;900721
+500;1592256;105898;11709378;273902;22697282;462435;18822538;574087
+600;1895442;130464;12047917;247568;25117703;456337;20575498;266024
+700;2213827;104975;12361110;300385;27882492;634943;22382673;573662
+800;2628305;201520;12754461;245304;30815541;974036;24578416;1370113
+900;2825817;162314;12993031;356629;33225179;414261;26037719;462749
+1000;3108772;170260;13431961;307448;35931523;507563;27869838;962124
+1100;3406111;146170;13777606;306016;38686328;485222;29861891;980317
+1200;3725777;156594;14126528;277721;41647628;705704;31178678;460041
+1300;4087469;156785;14358058;280611;44086243;460197;32979343;423141
+1400;4292505;167374;14846268;296761;46809938;541389;34869115;432616
+1500;4572214;225571;15114237;287681;49361025;279845;37212031;1781779
+1600;4923082;174615;15460129;327486;52305548;611924;38625303;1135684
+1700;5166483;153378;15791758;298803;54938031;513068;40254955;949560
+1800;5497751;209020;16085585;366356;58477674;1507994;41892868;498818
+1900;5805956;193667;16427008;257386;60505802;716086;43707906;813608
+2000;6059830;149468;16976318;415427;63510717;1323394;45371320;371778
+2100;6377742;190684;17196797;289761;66726951;1794964;47414718;1348167
+2200;6623121;189853;17470183;303551;68567720;1023095;49269993;1644584
+2300;6952906;176805;17876859;336883;69392158;10556124;50527003;363668
+2400;7288966;221144;18215274;381104;73997790;1207150;53676400;2638128
+2500;7687086;214686;18630693;393414;76931585;1135647;55006778;2629415
+2600;7632633;363416;18909524;344719;79271877;687461;55975072;345029
+2700;8174560;181199;19231438;387669;82347089;1557451;57872052;490032
+2800;8447899;213732;19670216;328248;84893831;1408698;59542864;265835
+2900;8804464;218130;19956270;431572;87686022;1182234;61601833;981957
+3000;9010784;248166;20376781;336594;91068853;1782507;63178755;558420
+3100;9331103;266569;20577490;278614;93221976;1568136;65392427;2128048
+3200;9778768;280983;20965405;359323;95722907;1632923;67069912;1365944
+3300;9909117;283939;21283196;422513;98212371;671946;68701884;1196483
+3400;10253423;272824;21563196;476725;100947909;1262629;70202232;398452
+3500;10549094;282951;22085786;363989;103828023;1230160;72095327;1412804
+3600;10932319;280437;22273127;312981;106331558;513011;74155843;1156209
+3700;11219472;293693;22752743;363381;109179786;1510549;75889598;1338718
+3800;11514828;307166;22943067;418169;111560051;338207;77553942;1357759
+3900;11824172;343282;23547573;417688;115156892;1981115;79134316;992767
+4000;12123878;296372;23814232;375398;117444661;1697465;80847115;834244
+4100;12526596;347080;24076190;411786;120001747;1042786;83079117;1736204
+4200;12715912;279629;24341732;416874;122699007;1258274;85512780;2631994
+4300;13111242;258811;24656266;428479;125560493;1443093;85918169;297761
+4400;13303073;325634;25067172;387431;127711585;372280;87929683;975369
+4500;13697463;356756;25683108;375100;130526503;693141;89582972;505995
+4600;13977464;344027;25925755;460848;133495971;1127336;91597602;1157872
+4700;14213956;470038;25919071;354324;136075667;1366941;93461991;1220158
+4800;14576705;375812;26600502;505971;139289408;1414807;94883034;524994
+4900;14708572;286603;26813061;385730;142436712;2843052;96930580;1047072
+5000;15199882;359091;27142509;386736;145702391;3939916;98716605;1358384

thesis/thesis.tex

@@ -11,7 +11,7 @@
 \Author{\authorname}                                    % The author's name in the document properties.
 \Title{Intercepting and Manipulating System/Function Calls in Linux Systems} % The document's title in the document properties.
 \Language{de-AT}                                        % The document's language in the document properties. Select 'en-US', 'en-GB', or 'de-AT'.
-\Keywords{a\sep list\sep of\sep keywords}               % The document's keywords in the document properties (separated by '\sep ').
+\Keywords{system call\sep syscall\sep function call\sep intercept\sep hook} % The document's keywords in the document properties (separated by '\sep ').
 \Publisher{TU Wien}                                     % The document's publisher in the document properties.
 \Subject{Thesis}                                        % The document's subject in the document properties.
 \end{filecontents*}
@@ -41,7 +41,17 @@
 \usepackage{chngcntr}
 \counterwithin{listing}{chapter}
 \usepackage{pgf-umlsd}
-%\usepackage{attachfile}
+\usepackage{textcomp}
+\usepackage{tikz}
+\usepackage{csvsimple}
+\usetikzlibrary{shapes}
+\usetikzlibrary{intersections}
+\usepackage{pgfplots}
+\usepgfplotslibrary{fillbetween}
+\usepgfplotslibrary{units}
+\usepackage[flushleft]{threeparttable}
+\usepackage{siunitx}
+\usepackage{attachfile}
 
 \newcommand{\newthreadShift}[4][gray!30]{
   \newinst[#4]{#2}{#3}
@@ -51,6 +61,8 @@
   \tikzstyle{instcolor#2}=[fill=#1]
 }
 
+\tikzset{elips/.style={ellipse,draw,minimum width=2em,minimum height=1.8em,inner ysep=0pt},}
+
 % Set PDF document properties
 \hypersetup{
     pdfpagelayout   = TwoPageRight,           % How the document is shown in PDF viewers (optional).
@@ -87,7 +99,7 @@
 
 % Required data.
 \setregnumber{12119052}
-\setdate{01}{06}{2025} % Set date with 3 arguments: {day}{month}{year}.
+\setdate{25}{08}{2025} % Set date with 3 arguments: {day}{month}{year}.
 \settitle{\thesistitle}{Abfangen und Manipulieren von\\System-/Funktionsaufrufen in\\Linux-Systemen} % Sets English and German version of the title (both can be English or German). If your title contains commas, enclose it with additional curvy brackets (i.e., {{your title}}) or define it as a macro as done with \thesistitle.
 %\setsubtitle{Optional Subtitle of the Thesis}{Optionaler Untertitel der Arbeit} % Sets English and German version of the subtitle (both can be English or German).
 
@@ -148,15 +160,17 @@
 \input{src/01.introduction}
 \input{src/02.intercept}
 \input{src/03.manipulate}
-\input{src/04.comparison}
-\input{src/05.related-work}
+\input{src/04.related-work}
+\input{src/05.evaluation}
 \input{src/06.conclusion}
 \backmatter
 
 % Declare the use of AI tools as mentioned in the statement of originality.
 % Use either the English aitools or the German kitools.
 \begin{aitools}
-\todo{Enter your text here.}
+  No generative AI tools were used in and for this work whatsoever.
+  The only exception was the use of ChatGPT for proofreading and refining of the abstract.
+  \todo{Remove}
 \end{aitools}
 
 %\begin{kitools}
@@ -167,15 +181,15 @@
 \listoffigures % Starred version, i.e., \listoffigures*, removes the toc entry.
 
 % Use an optional list of tables.
-\cleardoublepage % Start list of tables on the next empty right hand page.
+%\cleardoublepage % Start list of tables on the next empty right hand page.
 \listoftables % Starred version, i.e., \listoftables*, removes the toc entry.
 
 % Use an optional list of algorithms.
-\listofalgorithms
-\addcontentsline{toc}{chapter}{List of Algorithms}
+%\listofalgorithms
+%\addcontentsline{toc}{chapter}{List of Algorithms}
 
 % Use an optional list of listings.
-\cleardoublepage
+%\cleardoublepage
 \listof{listing}{\listoflistingscaption}
 \addcontentsline{toc}{chapter}{\listoflistingscaption}