Skip to content

U
uva
Commit efadd41a authored by Taddeus Kroes's avatar Taddeus Kroes
Browse files
Options

Merged branches.

parents 1833f32e 316aecce
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1875 additions and 1144 deletions
.gitignore
View file @ efadd41a
*.log
*.aux
*.o
*.pdf
*.swp
*.swo
*.toc
ass*.tar.gz
*.gz
compilerbouw/
robotica/
modsim/ass1/.gitignore 0 → 100644
View file @ efadd41a
sum.float
sum.double
sum
speed.*.*
speed
fp
float_double
report.pdf
fd*
pr
floating_point.tex
extra_precision.tex
speed.tex
sum.tex
Makefile.tex
kahan
kahan_sum.tex
modsim/ass1/Makefile 0 → 100644
View file @ efadd41a
CC=gcc
FLAGS=-Wall -Wextra -std=c99 -pedantic -O0 -lm
SPEED_TYPES=float double LD
SUM_TYPES=float double
OPS=ADD DIV MULT SQRT
all: fp speed highlight report.pdf sum kahan pr
highlight: floating_point.tex extra_precision.tex \
speed.tex sum.tex kahan_sum.tex Makefile.tex
s%.tex: s%.c
pygmentize -O style=colorful -o $@ $^
kahan_sum.tex: kahan_sum.c
pygmentize -O style=colorful -o $@ $^
Makefile.tex: Makefile
pygmentize -O style=colorful -o $@ $^
extra_precision.tex: extra_precision.c
pygmentize -O style=colorful -o $@ $^
floating_point.tex: floating_point.c
pygmentize -O style=colorful -o $@ $^
%.pdf: %.tex
pdflatex $^
pdflatex $^
speed: speed.c
for t in $(SPEED_TYPES); do \
for o in $(OPS); do \
sed "s#{TYPE}#$$t#" $^ | sed "s#{OP}#$$o#" > speed.$$t.$$o.c; \
$(CC) $(FLAGS) -o speed.$$t.$$o speed.$$t.$$o.c; \
rm speed.$$t.$$o.c; \
done; \
done;
touch $@
pr: extra_precision.o
$(CC) $(FLAGS) -mfpmath=387 -O2 -o $@ $^
fp: floating_point.o
$(CC) $(FLAGS) -o $@ $^
sum: sum.c
for t in $(SUM_TYPES); do \
sed "s#{TYPE}#$$t#" $^ > sum.$$t.c; \
$(CC) $(FLAGS) -o sum.$$t sum.$$t.c; \
rm sum.$$t.c; \
done;
touch $@
kahan: kahan_sum.o
$(CC) $(FLAGS) -o $@ $^
%.o: %.c
$(CC) $(FLAGS) -o $@ -c $^
%.s: %.c
$(CC) $(FLAGS) -o $* $^
clean:
rm -vf *.o *.i *.s fp pr fd* speed speed.*.* floating_point \
report.pdf *.aux *.log *.toc sum sum.float sum.double kahan
modsim/ass1/benchmark.bash 0 → 100755
View file @ efadd41a
for f in ./speed.[dfL]*; do
echo -n $f' ';
sleep 1;
sudo nice -n -20 time -f %U $f;
done
modsim/ass1/colors.tex 0 → 100644
View file @ efadd41a
% Template coming from Pygments (pygmentize with "-O full,preamble")
\usepackage{fancyvrb}
\usepackage{color}
\makeatletter
\def\PY@reset{\let\PY@it=\relax \let\PY@bf=\relax%
\let\PY@ul=\relax \let\PY@tc=\relax%
\let\PY@bc=\relax \let\PY@ff=\relax}
\def\PY@tok#1{\csname PY@tok@#1\endcsname}
\def\PY@toks#1+{\ifx\relax#1\empty\else%
\PY@tok{#1}\expandafter\PY@toks\fi}
\def\PY@do#1{\PY@bc{\PY@tc{\PY@ul{%
\PY@it{\PY@bf{\PY@ff{#1}}}}}}}
\def\PY#1#2{\PY@reset\PY@toks#1+\relax+\PY@do{#2}}
\def\PY@tok@gd{\def\PY@tc##1{\textcolor[rgb]{0.63,0.00,0.00}{##1}}}
\def\PY@tok@gu{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.50,0.00,0.50}{##1}}}
\def\PY@tok@gt{\def\PY@tc##1{\textcolor[rgb]{0.00,0.25,0.82}{##1}}}
\def\PY@tok@gs{\let\PY@bf=\textbf}
\def\PY@tok@gr{\def\PY@tc##1{\textcolor[rgb]{1.00,0.00,0.00}{##1}}}
\def\PY@tok@cm{\def\PY@tc##1{\textcolor[rgb]{0.50,0.50,0.50}{##1}}}
\def\PY@tok@vg{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.82,0.44,0.00}{##1}}}
\def\PY@tok@m{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.38,0.00,0.88}{##1}}}
\def\PY@tok@mh{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.31,0.50}{##1}}}
\def\PY@tok@cs{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.80,0.00,0.00}{##1}}}
\def\PY@tok@ge{\let\PY@it=\textit}
\def\PY@tok@vc{\def\PY@tc##1{\textcolor[rgb]{0.19,0.38,0.56}{##1}}}
\def\PY@tok@il{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.82}{##1}}}
\def\PY@tok@go{\def\PY@tc##1{\textcolor[rgb]{0.50,0.50,0.50}{##1}}}
\def\PY@tok@cp{\def\PY@tc##1{\textcolor[rgb]{0.31,0.44,0.56}{##1}}}
\def\PY@tok@gi{\def\PY@tc##1{\textcolor[rgb]{0.00,0.63,0.00}{##1}}}
\def\PY@tok@gh{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}}
\def\PY@tok@ni{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.50,0.00,0.00}{##1}}}
\def\PY@tok@nl{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.56,0.44,0.00}{##1}}}
\def\PY@tok@nn{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.05,0.52,0.71}{##1}}}
\def\PY@tok@no{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.19,0.38}{##1}}}
\def\PY@tok@na{\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.75}{##1}}}
\def\PY@tok@nb{\def\PY@tc##1{\textcolor[rgb]{0.00,0.44,0.13}{##1}}}
\def\PY@tok@nc{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.69,0.00,0.38}{##1}}}
\def\PY@tok@nd{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.31,0.31,0.31}{##1}}}
\def\PY@tok@ne{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.94,0.00,0.00}{##1}}}
\def\PY@tok@nf{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.38,0.69}{##1}}}
\def\PY@tok@si{\def\PY@bc##1{\colorbox[rgb]{0.88,0.88,0.88}{##1}}}
\def\PY@tok@s2{\def\PY@bc##1{\colorbox[rgb]{1.00,0.94,0.94}{##1}}}
\def\PY@tok@vi{\def\PY@tc##1{\textcolor[rgb]{0.19,0.19,0.69}{##1}}}
\def\PY@tok@nt{\def\PY@tc##1{\textcolor[rgb]{0.00,0.44,0.00}{##1}}}
\def\PY@tok@nv{\def\PY@tc##1{\textcolor[rgb]{0.56,0.38,0.19}{##1}}}
\def\PY@tok@s1{\def\PY@bc##1{\colorbox[rgb]{1.00,0.94,0.94}{##1}}}
\def\PY@tok@gp{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.78,0.36,0.04}{##1}}}
\def\PY@tok@sh{\def\PY@bc##1{\colorbox[rgb]{1.00,0.94,0.94}{##1}}}
\def\PY@tok@ow{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.00}{##1}}}
\def\PY@tok@sx{\def\PY@tc##1{\textcolor[rgb]{0.82,0.13,0.00}{##1}}
\def\PY@bc##1{\colorbox[rgb]{1.00,0.94,0.94}{##1}}}
\def\PY@tok@bp{\def\PY@tc##1{\textcolor[rgb]{0.00,0.44,0.13}{##1}}}
\def\PY@tok@c1{\def\PY@tc##1{\textcolor[rgb]{0.50,0.50,0.50}{##1}}}
\def\PY@tok@kc{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\def\PY@tok@c{\def\PY@tc##1{\textcolor[rgb]{0.50,0.50,0.50}{##1}}}
\def\PY@tok@mf{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.38,0.00,0.88}{##1}}}
\def\PY@tok@err{\def\PY@tc##1{\textcolor[rgb]{0.94,0.00,0.00}{##1}}
\def\PY@bc##1{\colorbox[rgb]{0.94,0.63,0.63}{##1}}}
\def\PY@tok@kd{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\def\PY@tok@ss{\def\PY@tc##1{\textcolor[rgb]{0.63,0.38,0.00}{##1}}}
\def\PY@tok@sr{\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.00}{##1}}
\def\PY@bc##1{\colorbox[rgb]{1.00,0.94,1.00}{##1}}}
\def\PY@tok@mo{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.25,0.00,0.88}{##1}}}
\def\PY@tok@mi{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.82}{##1}}}
\def\PY@tok@kn{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\def\PY@tok@o{\def\PY@tc##1{\textcolor[rgb]{0.19,0.19,0.19}{##1}}}
\def\PY@tok@kr{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\def\PY@tok@s{\def\PY@bc##1{\colorbox[rgb]{1.00,0.94,0.94}{##1}}}
\def\PY@tok@kp{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.19,0.50}{##1}}}
\def\PY@tok@w{\def\PY@tc##1{\textcolor[rgb]{0.73,0.73,0.73}{##1}}}
\def\PY@tok@kt{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.19,0.19,0.56}{##1}}}
\def\PY@tok@sc{\def\PY@tc##1{\textcolor[rgb]{0.00,0.25,0.82}{##1}}}
\def\PY@tok@sb{\def\PY@bc##1{\colorbox[rgb]{1.00,0.94,0.94}{##1}}}
\def\PY@tok@k{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\def\PY@tok@se{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.38,0.38,0.38}{##1}}
} % \def\PY@bc##1{\colorbox[rgb]{1.00,0.94,0.94}{##1}}}
\def\PY@tok@sd{\def\PY@tc##1{\textcolor[rgb]{0.82,0.25,0.13}{##1}}}
\def\PYZbs{\char`\\}
\def\PYZus{\char`\_}
\def\PYZob{\char`\{}
\def\PYZcb{\char`\}}
\def\PYZca{\char`\^}
% for compatibility with earlier versions
\def\PYZat{@}
\def\PYZlb{[}
\def\PYZrb{]}
\makeatother
modsim/ass1/extra_precision.c 0 → 100644
View file @ efadd41a
#include <stdio.h>
// Calculate 'e' using e=1+1/1!+1/2!+1/3!+1/4!+...
// 8! is 8x7x6x5x4x3x2x1. The series converges rapidly to e.
int fact(int x) { return x > 0 ? x * fact(x-1) : 1; }
int main(void) {
float last_e, e;
int i, max_first = fact(8), max_last = fact(7);
for(e = 1.f, i = 1; i < max_first; i *= i+1 )
e += 1.f / i;
last_e = e;
for(e = 1.f, i = 1; i < max_last; i *= i+1 )
e += 1.f / i;
if( last_e < e + 1.f / (i*8) )
printf("more precision detected!\n");
printf("first: %.80f\nlast : %.80f \n", last_e, e + 1.f / (i*8));
return 0;
}
simmod/ass1/floating_point.c → modsim/ass1/floating_point.c
View file @ efadd41a
......@@ -9,5 +9,15 @@ int main(void) {
PRINT_SIZE(double);
PRINT_SIZE(long double);
float e = 1.f; // Will be replaced in assembly
printf("our epsilon: %.12e\n", e);
printf("f range: [%e, %e]\n", FLT_MIN, FLT_MAX);
printf("d range: [%e, %e]\n", DBL_MIN, DBL_MAX);
printf("ld range: [%Le, %Le]\n", LDBL_MIN, LDBL_MAX);
printf("f epsilon: %e\n", FLT_EPSILON);
printf("d epsilon: %e\n", DBL_EPSILON);
printf("ld epsilon: %Le\n", LDBL_EPSILON);
return 0;
}
modsim/ass1/kahan_sum.c 0 → 100644
View file @ efadd41a
#include <stdlib.h>
#include <stdio.h>
float kahan_sum(int N) {
float sum = 0.0, c = 0.0, t, y;
for( int i = 1; i <= N; i++ ) {
y = 1.0/i - c;
t = sum + y;
c = (t - sum) - y;
sum = t;
}
return sum;
}
int main(void) {
printf("N = 1e8: %f\n", kahan_sum(1e8));
printf("N = 2e8: %f\n", kahan_sum(2e8));
return 0;
}
modsim/ass1/report.tex 0 → 100644
View file @ efadd41a
\documentclass[10pt,a4paper]{article}
\usepackage{float,url}
% Load code highlighter color scheme
\input{colors}
\title{Modelleren, Simuleren \& Contin\"ue Wiskunde \\
Assignment 1: Floating point arithmetic}
\author{Tadde\"us Kroes (6054129) \and Sander van Veen (6167969)}
\begin{document}
\maketitle
\section{Representation} % {{{
\label{sec:Representation}
We wrote a small C program to determine the properties of floating point numbers
(float, double and long double) on our working machine\footnote{Machine
info...}. To determine the size of the various data types, we used the
\texttt{sizeof} operator. The range of the mentioned data types can derived from
glibc's constants, like \texttt{FLT\_MAX}. Glibc also defines the machine precision
(epsilon) of each data type. \\
\\
The values we found are summarized in the table below:
\begin{table}[H]
\begin{tabular}{l|lll}
Data type & Bytes & Range & Epsilon \\
\hline
\texttt{float} & 4 & $[1.175494 \cdot 10^{38}, 3.402823 \cdot 10^{38}]$
& $1.192093 \cdot 10^{7}$ \\
\texttt{double} & 8 & $[2.225074 \cdot 10^{308}, 1.797693 \cdot 10^{308}]$
& $2.220446 \cdot 10^{16}$ \\
\texttt{long double} & 12 & $[3.362103 \cdot 10^{4932}, 1.189731 \cdot 10^{4932}]$
& $1.084202 \cdot 10^{19}$ \\
\end{tabular}
\caption{Floating point characteristics.}
\end{table}
We will explain the $\epsilon$ we found for the precision of the \texttt{float}
data type. First, we state that epsilon is the smallest representable number
greater than one (thus $a + \epsilon \neq a$, where $|a| \ge 1$). Given the
representation as defined in the lecture slides, we know that the 8-bit exponent
of $1$ is $01111111_2 = 127_{10}$, so $e = 127 - bias = 127 - 127 = 0$. The
mantissa are all zero except for the ``hidden bit'', which is 1. This gives the
exact number $1 \cdot 10^0 = 1.0$. The number closest to one can be made by
making the least significant mantissa `1'. If we apply the given formula, we get
the following decimal value:
$$ (-1)^{sign}(1 + \sum_{i=1}^{23} \ b_{i}2^{-i} )\cdot 2^{(e-127)}
= 1(1 + 1 \cdot 10^{-22}) \cdot 2^0 = 1.000000119209 = 1 + \epsilon $$
We noticed that the precision of numbers between -1 and 1 is much higher, as we
will show later in this report. We thought that the precision would be the same
as the $\epsilon$ which we calculated above, because the exponent is
$00000000_2$ which gives us $e = 0 - bias = -127$. There is no more hidden bit,
but since $2^{-126} = 2 \cdot 2^{-127}$ the precision should be the same. We
think that the higher precision is due to extra precision in the floating point
registers of our computer. Optimization is possible, because numbers between -1
and 1 are ``denormalized'', and therefore contain redundant representations.
% }}}
\section{Calculation speed} % {{{
\label{sec:Calculation speed}
We created one base source file, the executable benchmark files are generated
using the Makefile (which will substitute the variables). The benchmark can be
started using \texttt{./benchmark.bash}.
\begin{table}[H]
\begin{tabular}{l|ll}
Type & Operator & Million ops/sec \\
\hline
\texttt{float} & ADD & 311 \\
\texttt{double} & ADD & 296 \\
\texttt{long double} & ADD & 235 \\
\texttt{float} & DIV & 213 \\
\texttt{double} & DIV & 213 \\
\texttt{long double} & DIV & 190 \\
\texttt{float} & MULT & 9.57 \\
\texttt{double} & MULT & 9.58 \\
\texttt{long double} & MULT & 12.8 \\
\texttt{float} & SQRT & 190 \\
\texttt{double} & SQRT & 222 \\
\texttt{long double} & SQRT & 121 \\
\end{tabular}
\caption{Calculation speed of various mathematical operations.}
\end{table}
\noindent \textbf{Observations}
\begin{itemize}
\item We see that when the data type has a larger storage size, the addition
operation takes increasingly longer.
\item Division and multiplication performance are the same for the data
types \texttt{float} and \texttt{double}. However, division and
multiplication for the \texttt{long double} data type does take longer to
execute.
\item We notice that the square root operation is slower for the
\texttt{float} than for the \texttt{double} data type. Therefore, we think
that the \texttt{sqrt} function of glibc is optimised for the
\texttt{double} data type.
\end{itemize}
% }}}
\section{Summation} % {{{
\label{sec:Summation}
We've calculated $\sum_{i=1}^{N}\frac{1}{i}$ for $N = 10^8$ and $N = 2 \cdot
10^8$ using a forward and backward summation approach, with data types
\texttt{float} and \texttt{double}. The results of this are in the table below.
\begin{table}[H]
\begin{tabular}{l|llll}
Type & N & Forward & Backward & Kahan\\
\hline
\texttt{float} & $10^8$ & $15.403683$ & $18.807919$ & $18.997896$ \\
\texttt{float} & $2 \cdot 10^8$ & $15.403683$ & $18.807919$ & $19.691044$ \\
\texttt{double} & $10^8$ & $18.997896$ & $18.997896$ & \\
\texttt{double} & $2 \cdot 10^8$ & $19.691044$ & $19.691044$ & \\
\end{tabular}
\caption{Results of various summation approaches on floats and doubles.}
\end{table}
\noindent \textbf{Observations}
\begin{itemize}
\item Since the results for the \texttt{double} data type are equal for both
the forward and backward summation approach, we can say that these are the
correct results.
\item For the \texttt{float} data type, we observe that the backward approach
yields a higher result than the forward approach. This can be explained as
follows. When using the forward approach, we start with a small $i$, thus
with a large $1/i$. This means that the initial value of \texttt{sum} is
large. The value will keep growing until the significance of $1/i$ is too
small to add to the result. From this point, no more $1/i$ will be added to
the result because the significance of the individual numbers is too small.
However, the sum of the ignored numbers would be a large enough number to
add to the result. This is why the backward approach yields a higher number:
the sum of the ignored numbers is computed and later the larger numbers
are added. The remaining imprecision is probably due to rounding problems and
the fact that $1/10^8$ and a range of larger numbers are represented as
zeroes in \texttt{float} representation and therefore not added to the
result. This problem does not occur when using the \texttt{double} data type
which has a higher precision, therefore yielding the (correct) higher
result.
\item We can see that both approaches yield the same result for $N = 10^8$
and $N = 2 \cdot 10^8$ when using the \texttt{float} data type. This is due
to the same problem as described above: all numbers in $[\frac{1}{10^8},
\frac{1}{2 \cdot 10^8}]$ are also represented as zero and therefore not added
to the result.
\item To improve the precision of the \texttt{float} data type summation, we
implemented the Kahan summation algorithm. This algorithm basically divides the
summation in a higher- and lower-order part. The lower-order part is used to
compensate for the error at each summation. See
\url{http://en.wikipedia.org/wiki/Kahan_summation_algorithm} for more
information about this algorithm. The results are in the last column as the
table, we can see that the algorithm yields the correct number. We know this
because they are equal to the result of the \texttt{double} summations (but
rounded to the precision of a \texttt{float}, of course).
\end{itemize}
% }}}
\section{Extra precision} % {{{
\label{sec:Extra precision}
Our machine has an Intel Core2 Duo cpu (cpu type is E6750) running at 2.66GHz.
Because Intel added the x87 instruction set (a subset of x86), the FPU
(floating point unit) has a more precise floating point register.
To demonstrate this, we created simple C program, which will approximate the
constant $e$ twice. The first time it will save the final result in a float, the
second time it will store the result in the floating point register. The second
approximation is compared to the first and if the first approximation is large
than the second, the processor has a more precise floating point register. The
simple C program is listed in the appendix \ref{sec:extra_precision.c} and
produces this output:
\begin{verbatim}
$ ./pr
more precision detected!
first: 2.6910297870635986328125000000000000000000000000000000000
last : 2.6910298253667153112189680541632696986198425292968750000
\end{verbatim}
% }}}
\appendix{}
\section{floating\_point.c} % {{{
\label{sec:floating_point.c}
\input{floating_point}
% }}}
\section{speed.c} % {{{
\label{sec:speed.c}
\input{speed}
% }}}
\section{sum.c} % {{{
\label{sec:sum.c}
\input{sum}
% }}}
\section{kahan\_sum.c} % {{{
\label{sec:kahan_sum.c}
\input{kahan_sum}
% }}}
\section{extra\_precision.c} % {{{
\label{sec:extra_precision.c}
\input{extra_precision}
% }}}
\section{Makefile} % {{{
\label{sec:Makefile}
\input{Makefile}
% }}}
\end{document}
modsim/ass1/speed.c 0 → 100644
View file @ efadd41a
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#define ADD(a, b) (a += b)
#define DIV(a, b) (a /= b)
#define MULT(a, b) (a *= b)
// Macro expansion is on purpose here to suppress the `unused var b' warning.
#define SQRT(a, b) a = sqrt(a); b = b
#define LD long double
int main(void) {
int i, max = (int) 1e9;
{TYPE} a = 1.60654, b = 3.1285341;
for(i=0; i < max; i++)
{OP}(a, b);
return 0;
}
modsim/ass1/sum.c 0 → 100644
View file @ efadd41a
#include <stdlib.h>
#include <stdio.h>
{TYPE} sum_forward(int N) {
{TYPE} sum = 0;
for( int i = 1; i <= N; i++ )
sum += 1.0 / i;
return sum;
}
{TYPE} sum_backward(int N) {
{TYPE} sum = 0;
for( int i = N; i; i-- )
sum += 1.0 / i;
return sum;
}
int main(void) {
puts("Using type {TYPE}.");
puts("Forward summation:");
printf("N = 1e8: %f\n", sum_forward(1e8));
printf("N = 2e8: %f\n", sum_forward(2e8));
puts("Backward summation:");
printf("N = 1e8: %f\n", sum_backward(1e8));
printf("N = 2e8: %f\n", sum_backward(2e8));
return 0;
}
modsim/ass2/.gitignore 0 → 100644
View file @ efadd41a
q1
q2
q3
q4
q5
*.o
modsim/ass2/Makefile 0 → 100644
View file @ efadd41a
CC=clang
CFLAGS=-Wall -Wextra -pedantic -std=c99 -D_GNU_SOURCE
LFLAGS=-lm
all: q1 q2 q3
q1: q1.o
$(CC) $(CFLAGS) $(LFLAGS) -o $@ $^
q2: q2.o
$(CC) $(CFLAGS) $(LFLAGS) -o $@ $^
%.o: %.c
$(CC) $(CFLAGS) $(LFLAGS) -o $@ -c $^
clean:
for i in `seq 5`; do \
rm -vf q$$i; \
done;
rm -vf *.o
modsim/ass2/q1.c 0 → 100644
View file @ efadd41a
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#define H 1e-3
#define TABLE_LINE(func, x) (printf("%-24s%.12f\t%.12f\n", #x, \
slope_right(func, x, H), slope_central(func, x, H)))
typedef double (*func_ptr)(double x);
double slope_right(func_ptr func, double x, double h) {
return (func(x + h) - func(x)) / h;
}
double slope_central(func_ptr func, double x, double h) {
return (func(x + h) - func(x - h)) / (2 * h);
}
int main(void) {
puts("x\t\t\tright\t\tcentral");
TABLE_LINE(&sin, M_PI / 3);
TABLE_LINE(&sin, 100 * M_PI + M_PI / 3);
TABLE_LINE(&sin, 1e12 * M_PI + M_PI / 3);
return 0;
}
modsim/ass2/q2.c 0 → 100644
View file @ efadd41a
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#define EPSILON 1e-11
typedef double (*func_ptr)(double x);
double bisec(func_ptr f, double left, double right, int *steps) {
int i;
double mid;
for( i = 1; fabs(right - left) > 2 * EPSILON; i++ ) {
mid = (right + left) / 2;
if( f(left) * f(mid) < 0 )
right = mid;
else if( f(right) * f(mid) < 0 )
left = mid;
else
break;
}
*steps = i;
return mid;
}
double func(double x) {
return x * sin(x) - 1;
}
int main(void) {
int steps;
printf("zero point: %.20f\n", bisec(&func, 0, 2, &steps));
printf("Steps: %d\n", steps);
return 0;
}
modsim/ass2/q3.c 0 → 100644
View file @ efadd41a
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#define EPSILON 1e-11
typedef double (*func_ptr)(double x);
double bisec(func_ptr f, double left, double right, int *steps) {
int i;
double mid;
for( i = 1; fabs(right - left) > 2 * EPSILON; i++ ) {
mid = (right + left) / 2;
if( f(left) * f(mid) < 0 )
right = mid;
else if( f(right) * f(mid) < 0 )
left = mid;
else
break;
}
*steps = i;
return mid;
}
double func(double x) {
return x * sin(x) - 1;
}
int main(void) {
int steps;
printf("zero point: %.20f\n", bisec(&func, 0, 2, &steps));
printf("Steps: %d\n", steps);
return 0;
}
os/ass1/interval.c
View file @ efadd41a
/*
Author: G.D. van Albada
Date: August 26, 2009
(c) Universiteit van Amsterdam
Author: G.D. van Albada
Date: August 26, 2009
(c) Universiteit van Amsterdam
In this file the data types and some of the functions declared
in the file interval.h for the first assignment in the OS course
for 2009 are defined.
In this file the data types and some of the functions declared
in the file interval.h for the first assignment in the OS course
for 2009 are defined.
*/
/*
......@@ -26,9 +26,9 @@
#include "interval.h"
#include <math.h>
/*
/*
* Over the years the number of clock ticks per second has been
* called by many names. The code give here appears to work on most
* called by many names. The code give here appears to work on most
* machines.
* Use MY_CLK_TCK to convert the output of times() to seconds.
*/
......@@ -53,56 +53,56 @@ interval newInterval(void)
{
return NULL;
}
gettimeofday(&(nw->last_wct), NULL);
times(&(nw->last_cput));
if( !MY_CLK_TCK )
{
MY_CLK_TCK = sysconf(_SC_CLK_TCK);
MY_CLK_TCK = sysconf(_SC_CLK_TCK);
}
return nw;
}
/*
* Free the memory used by the interval pointer and set the pointer to NULL. If
* Free the memory used by the interval pointer and set the pointer to NULL. If
* the pointer is valid, zero is returned, or 1 otherwise.
*/
int delInterval(interval *intervalPtr)
{
if( intervalPtr == NULL )
return 1;
free(*intervalPtr);
*intervalPtr = NULL;
return 0;
if( intervalPtr == NULL )
return 1;
free(*intervalPtr);
*intervalPtr = NULL;
return 0;
}
/*
* Returns the wall clock time, user CPU time and system CPU time for the
* Returns the wall clock time, user CPU time and system CPU time for the
* calling process and its children consumed since the previous call for the
* specified interval. Returns zero on success, -1 when an invalid pointer is
* specified interval. Returns zero on success, -1 when an invalid pointer is
* passed as argument.
*/
int timeInterval(interval id, double *wct, double *ust, double *syt)
{
if( !id || wct == NULL || ust == NULL || syt == NULL )
return -1;
struct timeval last_wct = id->last_wct;
struct tms last_cput = id->last_cput;
if( delInterval(&id) )
return -1;
id = newInterval();
*wct = (id->last_wct.tv_sec + id->last_wct.tv_usec / 1e6)
- (last_wct.tv_sec + last_wct.tv_usec / 1e6);
*ust = difftime(id->last_cput.tms_utime, last_cput.tms_utime) / MY_CLK_TCK;
*syt = difftime(id->last_cput.tms_stime, last_cput.tms_stime) / MY_CLK_TCK;
return 0;
if( !id || wct == NULL || ust == NULL || syt == NULL )
return -1;
struct timeval last_wct = id->last_wct;
struct tms last_cput = id->last_cput;
if( delInterval(&id) )
return -1;
id = newInterval();
*wct = (id->last_wct.tv_sec + id->last_wct.tv_usec / 1e6)
- (last_wct.tv_sec + last_wct.tv_usec / 1e6);
*ust = difftime(id->last_cput.tms_utime, last_cput.tms_utime) / MY_CLK_TCK;
*syt = difftime(id->last_cput.tms_stime, last_cput.tms_stime) / MY_CLK_TCK;
return 0;
}
os/ass1/interval.h
View file @ efadd41a
/*
Author: G.D. van Albada
Date: August 26, 2009
(c) Universiteit van Amsterdam
Author: G.D. van Albada
Date: August 26, 2009
(c) Universiteit van Amsterdam
In this file the data types and functions exported by the file
interval.c for the first assignment in the OS course for 2009
are defined.
In this file the data types and functions exported by the file
interval.c for the first assignment in the OS course for 2009
are defined.
*/
/* interval is a pointer to a struct used by the functions
......
os/ass1/main.c
View file @ efadd41a
......@@ -16,68 +16,68 @@
void consume_time()
{
int i = 0, max = 1e6;
double x = 0, s, e;
srand(0);
while( i++ < max )
{
x += rand();
s = sqrt(x);
e = pow(10, log10(x)/2);
}
int i = 0, max = 1e6;
double x = 0, s, e;
srand(0);
while( i++ < max )
{
x += rand();
s = sqrt(x);
e = pow(10, log10(x)/2);
}
}
/*
*
*
*/
int main (int argc, char **argv)
{
interval id = newInterval();
// Benchmark the duration of a few system calls using timeInterval.
double wct = 0,
ust = 0,
syt = 0;
int i = 0, max = 1e2;
while( i++ < max )
{
consume_time();
(void) timeInterval(id, &wct, &ust, &syt);
printf("Task took %.3f sec (us: %.3f, sy: %.3f)\n", wct, ust, syt);
}
// Benchmark the duration of one million timeInterval calls.
i = 0;
double tmp_wc = 0,
tmp_us = 0,
tmp_sy = 0;
interval max_id = newInterval();
id = newInterval();
max = 1e6;
while( i++ < max )
{
(void) timeInterval(id, &tmp_wc, &tmp_us, &tmp_sy);
}
if( timeInterval(max_id, &wct, &ust, &syt) )
perror("timeInterval() returned a non-zero error code.");
fprintf(stderr, "%dx timeInterval took %.3f sec (us: %.3f, sy: %.3f)\n",
max, wct, ust, syt);
return (EXIT_SUCCESS);
interval id = newInterval();
// Benchmark the duration of a few system calls using timeInterval.
double wct = 0,
ust = 0,
syt = 0;
int i = 0, max = 1e2;
while( i++ < max )
{
consume_time();
(void) timeInterval(id, &wct, &ust, &syt);
printf("Task took %.3f sec (us: %.3f, sy: %.3f)\n", wct, ust, syt);
}
// Benchmark the duration of one million timeInterval calls.
i = 0;
double tmp_wc = 0,
tmp_us = 0,
tmp_sy = 0;
interval max_id = newInterval();
id = newInterval();
max = 1e6;
while( i++ < max )
{
(void) timeInterval(id, &tmp_wc, &tmp_us, &tmp_sy);
}
if( timeInterval(max_id, &wct, &ust, &syt) )
perror("timeInterval() returned a non-zero error code.");
fprintf(stderr, "%dx timeInterval took %.3f sec (us: %.3f, sy: %.3f)\n",
max, wct, ust, syt);
return (EXIT_SUCCESS);
}
os/ass1/meten.c
View file @ efadd41a
......@@ -11,12 +11,12 @@
#include "meten.h"
#include "testcache.h"
/*
* Afhankelijk van de machine, moet de maximale waarde van size tussen de 20 en
* 80 miljoen liggen, en de minimale bij een paar miljoen. De maximale waarde
* van stride moet ergens tussen de 100 000 en 200 000 liggen, en de minimale
* waarde moet 1 zijn. Zeker voor de kleinere waarden van size zullen de
* functies zo snel zijn dat je ze een flink aantal malen moet meten voordat je
/*
* Afhankelijk van de machine, moet de maximale waarde van size tussen de 20 en
* 80 miljoen liggen, en de minimale bij een paar miljoen. De maximale waarde
* van stride moet ergens tussen de 100 000 en 200 000 liggen, en de minimale
* waarde moet 1 zijn. Zeker voor de kleinere waarden van size zullen de
* functies zo snel zijn dat je ze een flink aantal malen moet meten voordat je
* een betrouwbare meting van met name de CPU-tijd hebt.
*/
static long cur_size = 1e6;
......@@ -28,104 +28,104 @@ static long max_stride = 2e5;
static long *data;
/*
* De invoerparameters omvatten in ieder geval een pointer naar een functie van
* het type van fillArray en sumArray, size en stride. De uitvoerparameters
* De invoerparameters omvatten in ieder geval een pointer naar een functie van
* het type van fillArray en sumArray, size en stride. De uitvoerparameters
* omvatten in ieder geval de gebruikte wall-clock tijd en de gebruikte CPU tijd
* voor de aanroep. Of je het te gebruiken array als parameter meegeeft, of
* voor de aanroep. Of je het te gebruiken array als parameter meegeeft, of
* binnen de functie zelf aanmaakt staat je vrij.
*/
void time_single_fn(array_fn* fn, double *wct, double *ust, double *syt)
{
interval now = newInterval();
double t_w = 0, t_u = 0, t_s = 0;
int i = 0;
do
{
(*fn)(data, cur_size, cur_stride);
timeInterval(now, &t_w, &t_u, &t_s);
*wct += t_w;
*ust += t_u;
*syt += t_s;
i++;
}
while( *wct < 1 );
if( i > 1 )
{
*wct /= i;
*ust /= i;
*syt /= i;
}
interval now = newInterval();
double t_w = 0, t_u = 0, t_s = 0;
int i = 0;
do
{
(*fn)(data, cur_size, cur_stride);
timeInterval(now, &t_w, &t_u, &t_s);
*wct += t_w;
*ust += t_u;
*syt += t_s;
i++;
}
while( *wct < 1 );
if( i > 1 )
{
*wct /= i;
*ust /= i;
*syt /= i;
}
}
/*
* Deze functie gebruikt de bovengenoemde functie om achtereenvolgens de
* performance te meten van een gegeven functie voor een reeks van waarden voor
* size en stride. Een beetje afhankelijk van de machine waarop je werkt, moet
* Deze functie gebruikt de bovengenoemde functie om achtereenvolgens de
* performance te meten van een gegeven functie voor een reeks van waarden voor
* size en stride. Een beetje afhankelijk van de machine waarop je werkt, moet
* de maximale waarde van size tussen de 20 en 80 miljoen liggen, en de minimale
* bij een paar miljoen. De maximale waarde van stride moet ergens tussen de
* 100 000 en 200 000 liggen, en de minimale waarde moet 1 zijn. Zeker voor de
* bij een paar miljoen. De maximale waarde van stride moet ergens tussen de
* 100 000 en 200 000 liggen, en de minimale waarde moet 1 zijn. Zeker voor de
* kleinere waarden van size zullen de functies zo snel zijn dat je ze een flink
* aantal malen moet meten voordat je een betrouwbare meting van met name de
* CPU-tijd hebt.
*
* Druk voor iedere combinatie van size en stride een regel af met de diverse
* Druk voor iedere combinatie van size en stride een regel af met de diverse
* meetwaarden en de naam van de geteste functie. Om je resultaten met elkaar te
* kunnen vergelijken kan je de waarde per geheugen-access berekenen.
*
* N.B.2 schrijf je routine zo dat de te meten routine herhaald wordt
* aangeroepen totdat een vooraf bepaalde hoeveelheid CPU tijd is gebruikt
* N.B.2 schrijf je routine zo dat de te meten routine herhaald wordt
* aangeroepen totdat een vooraf bepaalde hoeveelheid CPU tijd is gebruikt
* (b.v. 0.5 seconde). Tel het aantal aanroepen.
*
* N.B.3 als je de velden in de regel met een tab scheidt, kan je die later
* N.B.3 als je de velden in de regel met een tab scheidt, kan je die later
* eenvoudig in een spreadsheet inlezen.
*/
void time_fn(array_fn* fn, double *wct, double *ust, double *syt)
{
for( cur_size = min_size; cur_size <= max_size; cur_size += cur_size )
{
for( cur_stride = min_stride;
cur_stride <= max_stride;
cur_stride *= 10 )
{
*wct = 0;
*ust = 0;
*syt = 0;
time_single_fn(fn, wct, ust, syt);
printf("%9.ld\t%6.ld\t%.3f\t%.3f\t%.3f\n",
cur_size, cur_stride, *wct, *ust, *syt);
}
}
for( cur_size = min_size; cur_size <= max_size; cur_size += cur_size )
{
for( cur_stride = min_stride;
cur_stride <= max_stride;
cur_stride *= 10 )
{
*wct = 0;
*ust = 0;
*syt = 0;
time_single_fn(fn, wct, ust, syt);
printf("%9.ld\t%6.ld\t%.3f\t%.3f\t%.3f\n",
cur_size, cur_stride, *wct, *ust, *syt);
}
}
}
/*
* Deze functie doet de nodige initialisaties, drukt minimaal een kopregel voor
* de tabel af, en roept timeAFunction aan voor de beide routines fillArray en
* Deze functie doet de nodige initialisaties, drukt minimaal een kopregel voor
* de tabel af, en roept timeAFunction aan voor de beide routines fillArray en
* sumArray.
*/
int main (int argc, char **argv)
{
data = malloc(max_size * sizeof(long *));
double wct = 0, ust = 0, syt = 0;
puts("### fillArray ###");
puts("size \tstride\ttime\tuser\tsys");
time_fn(&fillArray, &wct, &ust, &syt);
puts("### sumArray ###");
puts("size \tstride\ttime\tuser\tsys");
time_fn(&sumArray, &wct, &ust, &syt);
return (EXIT_SUCCESS);
data = malloc(max_size * sizeof(long *));
double wct = 0, ust = 0, syt = 0;
puts("### fillArray ###");
puts("size \tstride\ttime\tuser\tsys");
time_fn(&fillArray, &wct, &ust, &syt);
puts("### sumArray ###");
puts("size \tstride\ttime\tuser\tsys");
time_fn(&sumArray, &wct, &ust, &syt);
return (EXIT_SUCCESS);
}
os/ass1/testcache.c
View file @ efadd41a
......@@ -3,7 +3,7 @@
/* This is a very very basic test of cache behaviour */
/*
* We'll use a big array, say NELEMENTS in size
* We'll use a big array, say NELEMENTS in size
* The goal is to add up the values in that array, but we'll
* use a double loop and a STRIDE. The outer loop increments
* the start element, the inner loop strides through the array
......@@ -12,14 +12,14 @@
/*
* Fill the array with values, but in a possibly cache-unfriendly
* manner. The array should contain at least "size" elements.
* The function returns a long so as to ensure that it has the
* The function returns a long so as to ensure that it has the
* same type as the sumArray function below.
*/
long fillArray(long *array, int size, int stride)
{
int start;
int i = 0;
for (start = 0; start < stride; start++)
{
for (i = start; i < size; i += stride)
......@@ -27,7 +27,7 @@ long fillArray(long *array, int size, int stride)
array[i] = i;
}
}
return (long) i;
}
......@@ -43,7 +43,7 @@ long sumArray(long *array, int size, int stride)
int start;
int i;
long sum = 0;
for( start = 0; start < stride; start++ )
{
for( i = start; i < size; i += stride )
......@@ -51,6 +51,6 @@ long sumArray(long *array, int size, int stride)
sum += array[i];
}
}
return sum;
}
os/ass2/mem_alloc.h
View file @ efadd41a
......@@ -45,11 +45,11 @@ void mem_available(long *empty, long *large, long *n_holes);
/* mem_available vertelt de gebruiker hoeveel geheugen er nog
beschikbaar is
empty: totale hoeveelheid vrije ruimte
large: omvang van het grootste gat, gecorrigeerd voor
administratie
n_holes: het aantal gaten
*/
empty: totale hoeveelheid vrije ruimte
large: omvang van het grootste gat, gecorrigeerd voor
administratie
n_holes: het aantal gaten
*/
void mem_exit();
......
os/ass2/mt19937.h
View file @ efadd41a
/*
/*
Header file for mt19937ar.c
A C-program for MT19937, with initialization improved 2002/1/26.
Coded by Takuji Nishimura and Makoto Matsumoto.
Before using, initialize the state by using init_genrand(seed)
Before using, initialize the state by using init_genrand(seed)
or init_by_array(init_key, key_length).
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
All rights reserved.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The names of its contributors may not be used to endorse or promote
products derived from this software without specific prior written
permission.
3. The names of its contributors may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
......@@ -38,8 +38,8 @@
Any feedback is very welcome.
http://www.math.keio.ac.jp/matumoto/emt.html
email: matumoto@math.keio.ac.jp
http://www.math.keio.ac.jp/matumoto/emt.html
email: matumoto@math.keio.ac.jp
*/
/* initializes mt[N] with a seed */
......
os/ass2/mt19937ar.c
View file @ efadd41a
/*
/*
A C-program for MT19937, with initialization improved 2002/1/26.
Coded by Takuji Nishimura and Makoto Matsumoto.
Before using, initialize the state by using init_genrand(seed)
Before using, initialize the state by using init_genrand(seed)
or init_by_array(init_key, key_length).
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
All rights reserved.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The names of its contributors may not be used to endorse or promote
products derived from this software without specific prior written
permission.
3. The names of its contributors may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
......@@ -37,13 +37,13 @@
Any feedback is very welcome.
http://www.math.keio.ac.jp/matumoto/emt.html
email: matumoto@math.keio.ac.jp
http://www.math.keio.ac.jp/matumoto/emt.html
email: matumoto@math.keio.ac.jp
*/
#include <stdio.h>
/* Period parameters */
/* Period parameters */
#define N 624
#define M 397
#define MATRIX_A 0x9908b0dfUL /* constant vector a */
......@@ -58,8 +58,8 @@ void init_genrand(unsigned long s)
{
mt[0]= s & 0xffffffffUL;
for (mti=1; mti<N; mti++) {
mt[mti] =
(1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
mt[mti] =
(1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
/* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
/* In the previous versions, MSBs of the seed affect */
/* only MSBs of the array mt[]. */
......@@ -73,7 +73,7 @@ void init_genrand(unsigned long s)
/* init_key is the array for initializing keys */
/* key_length is its length */
void init_by_array(init_key, key_length)
unsigned long init_key[], key_length;
unsigned long init_key[], key_length;
{
int i, j, k;
init_genrand(19650218UL);
......@@ -81,7 +81,7 @@ unsigned long init_key[], key_length;
k = (N>key_length ? N : key_length);
for (; k; k--) {
mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL))
+ init_key[j] + j; /* non linear */
+ init_key[j] + j; /* non linear */
mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
i++; j++;
if (i>=N) { mt[0] = mt[N-1]; i=1; }
......@@ -89,13 +89,13 @@ unsigned long init_key[], key_length;
}
for (k=N-1; k; k--) {
mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL))
- i; /* non linear */
- i; /* non linear */
mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
i++;
if (i>=N) { mt[0] = mt[N-1]; i=1; }
}
mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
}
/* generates a random number on [0,0xffffffff]-interval */
......@@ -124,7 +124,7 @@ unsigned long genrand_int32(void)
mti = 0;
}
y = mt[mti++];
/* Tempering */
......@@ -145,29 +145,29 @@ long genrand_int31(void)
/* generates a random number on [0,1]-real-interval */
double genrand_real1(void)
{
return genrand_int32()*(1.0/4294967295.0);
/* divided by 2^32-1 */
return genrand_int32()*(1.0/4294967295.0);
/* divided by 2^32-1 */
}
/* generates a random number on [0,1)-real-interval */
double genrand_real2(void)
{
return genrand_int32()*(1.0/4294967296.0);
return genrand_int32()*(1.0/4294967296.0);
/* divided by 2^32 */
}
/* generates a random number on (0,1)-real-interval */
double genrand_real3(void)
{
return (((double)genrand_int32()) + 0.5)*(1.0/4294967296.0);
return (((double)genrand_int32()) + 0.5)*(1.0/4294967296.0);
/* divided by 2^32 */
}
/* generates a random number on [0,1) with 53-bit resolution*/
double genrand_res53(void)
{
unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
return(a*67108864.0+b)*(1.0/9007199254740992.0);
}
double genrand_res53(void)
{
unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
return(a*67108864.0+b)*(1.0/9007199254740992.0);
}
/* These real versions are due to Isaku Wada, 2002/01/09 added */
os/ass2/scheduler.c
View file @ efadd41a
This diff is collapsed.
os/ass2/scheduler.h
View file @ efadd41a
This diff is collapsed.
os/ass3/fishbones.c
View file @ efadd41a
This diff is collapsed.
os/ass4/main.c
View file @ efadd41a
/*
* Assignment 4 of Operating Systems: PThread simulation.
*
*
* Sander van Veen (6167969) and Taddeus Kroes (6054129).
* <sandervv@gmail.com> and <taddeuskroes@hotmail.com>.
*
*
* Submission date: 21 november 2010.
*/
......@@ -28,14 +28,14 @@ int diner_finished = 0;
/*
* Release fork taken by a philosopher.
*/
static inline void release_fork(diner_stats *stats, int f) {
if(diner_finished)
return;
// Unlock left or right fork.
stats->locked ^= 1 << (f % 2);
pthread_mutex_unlock(forks+f);
}
static inline void release_fork(diner_stats *stats, int f) {
if(diner_finished)
return;
// Unlock left or right fork.
stats->locked ^= 1 << (f % 2);
pthread_mutex_unlock(forks+f);
}
/*
* Try to claim a fork, but do not wait if the fork cannot be claimed.
......@@ -48,40 +48,40 @@ static inline int try_take_fork(diner_stats *stats, int f) {
stats->locked |= 1 << (f % 2);
stats->forks++;
return 0;
}
/*
* Claim a fork, and wait (blocking) if the fork is already taken.
*/
static inline void take_fork(diner_stats *stats, int f) {
if(diner_finished)
return;
static inline void take_fork(diner_stats *stats, int f) {
if(diner_finished)
return;
// Lock left or right fork.
pthread_mutex_lock(forks+f);
stats->locked |= 1 << (f % 2);
stats->forks++;
}
// Lock left or right fork.
pthread_mutex_lock(forks+f);
stats->locked |= 1 << (f % 2);
stats->forks++;
}
#define PHILO_EATING \
if(diner_finished) \
return 1; \
\
stats->meals++;
return 1; \
\
stats->meals++;
static const char *philo_type_names[] = {"left", "right", "optimistic", "shy",
"random"};
"random"};
static const philo_t philo_types[] = {&philo_left, &philo_right, &philo_shy, \
&philo_optimistic, &philo_random};
&philo_optimistic, &philo_random};
static const int philo_type_count = sizeof(philo_types) / sizeof(philo_t);
/*
* Philosopher favoring the left fork above the right fork. He will wait for
* both forks, and wouldn't release the first while he is waiting on the second.
*/
*/
int philo_left(diner_stats *stats, int id) {
// Let the philosopher take two forks (first left, then right).
take_fork(stats, id);
......@@ -99,14 +99,14 @@ int philo_left(diner_stats *stats, int id) {
/*
* Philosopher favoring the right fork above the left fork. He will wait for
* both forks, and wouldn't release the first while he is waiting on the second.
*/
*/
int philo_right(diner_stats *stats, int id) {
// Let the philosopher take two forks (first right, then left).
take_fork(stats, (id+1) % forks_len);
take_fork(stats, id);
PHILO_EATING;
// Release both forks.
release_fork(stats, id);
release_fork(stats, (id+1) % forks_len);
......@@ -115,7 +115,7 @@ int philo_right(diner_stats *stats, int id) {
}
/*
* Philosopher with optimistic behaviour: try to take the left or right fork,
* Philosopher with optimistic behaviour: try to take the left or right fork,
* and if one fork is taken succesfully, wait till the second fork is released.
*/
int philo_optimistic(diner_stats *stats, int id) {
......@@ -168,7 +168,7 @@ int philo_shy(diner_stats *stats, int id) {
if(!try_take_fork(stats, (id+1) % forks_len)) {
if(diner_finished)
return 1;
// Failed to take fork, so try again next time.
sched_yield();
}
......@@ -207,14 +207,14 @@ void *philo_start(void *raw_stats) {
diner_stats *stats = (diner_stats *) raw_stats;
int id = stats->id,
type = rand() % philo_type_count;
printf("P #%u: hello everybody, i'm %s!\n", id, philo_type_names[type]);
// Philosophers wait for each other, before they can start eating diner.
pthread_barrier_wait(&wait_barrier);
printf("P #%u: let's eating!\n", id);
while(!diner_finished && !(*philo_types[type])(stats, id));
printf("P #%u: i'm leaving, after paying the bill.\n", id);
......@@ -258,7 +258,7 @@ void host_start(int philos) {
// Invite the philosophers.
for(int i = 0; i < philos; i++) {
printf("Host: inviting philo #%d\n", i);
rc = pthread_create(threads+i, &attr, philo_start, (void*)&stats[i]);
if(rc) {
......@@ -266,19 +266,19 @@ void host_start(int philos) {
exit(-1);
}
}
puts("Host: invitations done.");
struct timeval wct;
gettimeofday(&wct, NULL);
double start_time = wct.tv_sec + wct.tv_usec / 1e6;
// Duration of the diner party is 10 seconds (see main.h). This loop will
// prevent the philosphers from exceeding this time limit.
do {
// Check each 10 ms for deadlock.
usleep(10000);
// If an deadlock occured (all philosophers are waiting on their left or
// right fork), finish the diner party immidiately. It is unclear in the
// assignment, if the philosophers should leave the diner party, or if
......@@ -286,8 +286,8 @@ void host_start(int philos) {
// assumption: leave the party. If they start arguing which fork is
// theirs, there's no party anymore.
int p;
for(p = 0; p < philos && (stats[p].locked & 1
|| stats[p].locked & 2); p++);
for(p = 0; p < philos && (stats[p].locked & 1
|| stats[p].locked & 2); p++);
if( p == philos ) {
puts("Host: deadlock occured.");
......@@ -302,12 +302,12 @@ void host_start(int philos) {
diner_finished = 1;
puts("Host: diner is finished.");
for(int i = 0; i < philos; i++) {
// Reclaim all cutlery (mutexes) in reverse order.
for(int p = philos; p >= i; p--)
pthread_mutex_unlock(&forks[p]);
// Wait on the other philosophers.
if( (rc = pthread_join(threads[i], &status)) ) {
fprintf(stderr, "return code from pthread_join() is %d\n", rc);
......@@ -315,16 +315,16 @@ void host_start(int philos) {
}
printf("Philo #%d ate %d meal(s) and grabbed %d fork(s).\n",
i, stats[i].meals, stats[i].forks);
i, stats[i].meals, stats[i].forks);
pthread_mutex_destroy(&forks[i]);
}
puts("Host: philosophers are done.");
pthread_barrier_destroy(&wait_barrier);
pthread_attr_destroy(&attr);
pthread_exit(NULL);
}
......@@ -340,7 +340,7 @@ int main(int argc, const char **argv) {
struct timeval wtc;
gettimeofday(&wtc, NULL);
srand(wtc.tv_usec);
host_start( argc > 1 ? atoi(argv[1]) : 2 );
}
os/ass5/index.c
View file @ efadd41a
......@@ -93,13 +93,13 @@ int index_error = 0;
* characterised by Nblocks (the maximum number of entries in the index)
* and KeyLength (the length of the key strings).
*/
in_core *
in_core *
index_makeNew(unsigned long Nblocks, unsigned long KeyLength)
{
unsigned long iRecordLength = sizeof(indexRecord) - sizeof(char[8]) +
4 * KeyLength;
in_core *in = calloc(1, sizeof(in_core) - sizeof(indexRecord) +
iRecordLength);
iRecordLength);
int i;
int levs;
int n;
......@@ -176,10 +176,10 @@ long index_writeToDisk(in_core * in, int fid)
}
rv = write(fid, &(in->to_disk),
sizeof(indexheader) - sizeof(indexRecord) + in->to_disk.iRecordLength);
sizeof(indexheader) - sizeof(indexRecord) + in->to_disk.iRecordLength);
if (rv != (int)(sizeof(indexheader) - sizeof(indexRecord) +
in->to_disk.iRecordLength)) {
in->to_disk.iRecordLength)) {
index_error = INDEX_WRITE_FAIL;
return -1;
}
......@@ -188,10 +188,10 @@ long index_writeToDisk(in_core * in, int fid)
#endif
for (i = 0; i < in->to_disk.Nlevels; i++) {
rv = write(fid, in->levels[i], in->to_disk.NperLevel[i] *
in->to_disk.iRecordLength);
in->to_disk.iRecordLength);
if (rv != (int)(in->to_disk.NperLevel[i]
* in->to_disk.iRecordLength)) {
* in->to_disk.iRecordLength)) {
index_error = INDEX_WRITE_FAIL;
return -1;
}
......@@ -230,7 +230,7 @@ in_core *index_readFromDisk(int fid)
assert(head.iRecordLength == in->to_disk.iRecordLength);
assert(head.Nlevels == in->to_disk.Nlevels);
assert(head.NperLevel[head.Nlevels - 1] ==
in->to_disk.NperLevel[head.Nlevels - 1]);
in->to_disk.NperLevel[head.Nlevels - 1]);
in->to_disk = head;
rv = read(fid, &(in->to_disk.root), head.iRecordLength);
if (rv != (int)head.iRecordLength) {
......@@ -246,8 +246,8 @@ in_core *index_readFromDisk(int fid)
printf("NperLevel[%d] = %d\n", i, in->to_disk.NperLevel[i]);
#endif
if (read(fid, in->levels[i],
in->to_disk.NperLevel[i] * in->to_disk.iRecordLength)
!= (int)(in->to_disk.NperLevel[i] * in->to_disk.iRecordLength))
in->to_disk.NperLevel[i] * in->to_disk.iRecordLength)
!= (int)(in->to_disk.NperLevel[i] * in->to_disk.iRecordLength))
{
index_error = INDEX_READ_ERROR;
return NULL;
......@@ -263,7 +263,7 @@ in_core *index_readFromDisk(int fid)
* it will return -1. (Zero is a valid index value) It needs as input: The
* sought key The index record The length of the keys.
*/
static long
static long
key_to_index(indexRecord * rec, const char *key, unsigned long KeyLength)
{
int rv;
......@@ -311,7 +311,7 @@ long index_keyToBlock(in_core * in, const char *key)
for (i = 0; i < in->to_disk.Nlevels; i++) {
rec = (indexRecord *) (index * in->to_disk.iRecordLength +
(char *)in->levels[i]);
(char *)in->levels[i]);
index = key_to_index(rec, key, KeyLength);
if (index < 0) {
index_error = INDEX_INDEXING_ERROR;
......@@ -359,7 +359,7 @@ int index_addKey(in_core * in, const char *key, int index)
nrec = (keyno - 1) / 4;
nkey = (keyno - 1) & 0x0003;
rec = (indexRecord *) (nrec * in->to_disk.iRecordLength +
(char *)in->levels[lev]);
(char *)in->levels[lev]);
rv = strncmp(key, KeyInRec(nkey, *rec, KeyLength), KeyLength);
if (rv <= 0) {
index_error = INDEX_KEY_NOT_LARGER;
......@@ -372,10 +372,10 @@ int index_addKey(in_core * in, const char *key, int index)
nrec = keyno / 4;
nkey = keyno & 0x0003;
rec = (indexRecord *) (nrec * in->to_disk.iRecordLength +
(char *)in->levels[lev]);
(char *)in->levels[lev]);
#ifdef DEBUG
printf("nrec = %d, nkey = %d, lev = %d, NperLevel = %d\n",
nrec, nkey, lev, in->to_disk.NperLevel[lev]);
nrec, nkey, lev, in->to_disk.NperLevel[lev]);
#endif
strncpy(KeyInRec(nkey, *rec, KeyLength), key, KeyLength);
do_prev = !nkey;
......@@ -394,10 +394,10 @@ int index_addKey(in_core * in, const char *key, int index)
nkey = keyno & 0x0003;
#ifdef DEBUG
printf("nrec = %d, nkey = %d, lev = %d, NperLevel = %d\n",
nrec, nkey, lev, in->to_disk.NperLevel[lev]);
nrec, nkey, lev, in->to_disk.NperLevel[lev]);
#endif
rec = (indexRecord *) (nrec * in->to_disk.iRecordLength +
(char *)in->levels[lev]);
(char *)in->levels[lev]);
strncpy(KeyInRec(nkey, *rec, KeyLength), key, KeyLength);
do_prev = !nkey;
rec->index[nkey] = keyno;
......
os/ass5/index.h
View file @ efadd41a
......@@ -2,17 +2,17 @@
#define INDEX_H
/* -------------------------------------------------------------------------
Author: G.D. van Albada
University of Amsterdam
Faculty of Science
Informatics Institute
Copyright (C) Universiteit van Amsterdam
dick at science.uva.nl
Version: 0.1
Date: December 2001 / January 2002 / November 2004
Goal: Part of an assignment on file system structure for the operating
systems course. It demonstrates many of the administrative and
layering structures that are also used in normal file systems.
Author: G.D. van Albada
University of Amsterdam
Faculty of Science
Informatics Institute
Copyright (C) Universiteit van Amsterdam
dick at science.uva.nl
Version: 0.1
Date: December 2001 / January 2002 / November 2004
Goal: Part of an assignment on file system structure for the operating
systems course. It demonstrates many of the administrative and
layering structures that are also used in normal file systems.
----------------------------------------------------------------------------*/
extern int index_error;
......
os/ass5/isam.c
View file @ efadd41a
This diff is collapsed.
os/ass5/isam.h
View file @ efadd41a
This diff is collapsed.
os/ass5/isam_bench.c
View file @ efadd41a
......@@ -48,7 +48,7 @@ static int report = 0;
* Bereken dagnummer met 1/1/1900 == 1
* Routine faalt op en na 1/3/2100
*/
static long
static long
berekenDag(int dag, int maand, int jaar)
{
long dagen;
......@@ -91,7 +91,7 @@ berekenDag(int dag, int maand, int jaar)
/*
* Print klant-informatie
*/
static void
static void
printKlant(FILE * log, char *kop, char *sleutel, klant * Klant)
{
if (kop) {
......@@ -107,7 +107,7 @@ printKlant(FILE * log, char *kop, char *sleutel, klant * Klant)
/*
* Maak een random klant
*/
static void
static void
maakKlant(klant *nieuweKlant)
{
int i, dag, maand, jaar;
......@@ -147,7 +147,7 @@ static int code = 1000;
* Maak een random sleutel, dichtbij de postcode in "code". Verhoog code.
* Sleutel is een postcode plus huisnummer.
*/
static int
static int
maakSleutel(char *sleutel)
{
int huisnummer;
......@@ -169,7 +169,7 @@ maakSleutel(char *sleutel)
/*
* Schrijf een nieuw record op een willekeurige plek in het bestand
*/
static int
static int
randomNieuwRecord(isamPtr ip)
{
char sleutel[20];
......@@ -201,7 +201,7 @@ randomNieuwRecord(isamPtr ip)
* Lees sequentieel alle records in bepaald sleutelbereik, en pleeg een
* bewerking
*/
static int
static int
leesBereik(isamPtr ip, char *minSleutel, char *maxSleutel, int datum)
{
char sleutel[20];
......@@ -265,7 +265,7 @@ leesBereik(isamPtr ip, char *minSleutel, char *maxSleutel, int datum)
}
int
int
leesBestaandRecord(isamPtr ip, int sleutelNr)
{
klant klantRecord;
......@@ -283,7 +283,7 @@ leesBestaandRecord(isamPtr ip, int sleutelNr)
return rv;
}
int
int
poetsBestaandRecord(isamPtr ip, int sleutelNr)
{
klant klantRecord;
......@@ -310,7 +310,7 @@ poetsBestaandRecord(isamPtr ip, int sleutelNr)
return rv;
}
int
int
main(int argc, char *argv[])
{
isamPtr ip;
......
os/ass5/isam_test.c
View file @ efadd41a
......@@ -24,7 +24,7 @@ code - it lacks comments, naming is ad-hoc, etc.
#include <string.h>
#include "isam.h"
void
void
instruct(void)
{
char str[256];
......@@ -65,7 +65,7 @@ instruct(void)
printf("\n");
}
int
int
main(int argc, char *argv[])
{
int rv, i;
......
os/extra/src/report/.gitignore 0 → 100644
View file @ efadd41a
*.log
*.toc
*.aux
report.pdf
report-dot2tex*
dot2tex.cache
os/extra/src/report/Makefile 0 → 100644
View file @ efadd41a
all:
pdflatex report.tex
portfolio/vcs/vcs.tex
View file @ efadd41a
......@@ -360,8 +360,9 @@ fill in the names of files you expect to show up in the directory.
In Git, it is not necessary to mention the renaming of files (since Git tracks
content, not files). However, it is required to add the renamed file to Git's
index, otherwise the file is marked as ``deleted''. Git provides a command to
move (or rename) files and directories: \texttt{git mv foo bar}.
index, otherwise the file is marked as ``deleted''. Also, Git provides a command to
move (or rename) files and directories: \texttt{git mv foo bar}. This will save
you one command to type, compared to \texttt{mv foo bar; git add bar}.
% }}}
......@@ -369,9 +370,10 @@ move (or rename) files and directories: \texttt{git mv foo bar}.
\label{sub:discarding-changes}
If you suddenly think your changes are not necessary or not the right solution,
you can discard those changes in Git using \texttt{git checkout -- baz.txt}. Or you
could reset your source tree to the last commit (thus discarding all changes in
all tracked files made since the last commit) using \texttt{git reset --hard HEAD}.
you can discard those changes in Git using \texttt{git checkout -- baz.txt} for
a single file or directory. Or you could reset your entire source tree to the
last commit (thus discarding all changes in all tracked files made since the
last commit) using \texttt{git reset --hard HEAD}.
% }}}
......@@ -445,19 +447,19 @@ to your index in a row.
When you want to create an experimental feature, which will break functionality,
it is wise to create a branch. Creating a branch makes it possible to commit
your changes, while other developers can continue their work. If you do not
your changes, while other developers can continue their work. If you do not
create a branch, it is possible that the other developers cannot continue,
because your commit broke some functionality they are depending on. When your
because your commit broke some functionality they are depending on. When your
feature is stable, you can merge the two branches and your feature is included
in the ``main'' source tree. Branches enable parallel development across the
developers. Git is designed to handle large branches and merging those branches
efficiently. Also notice when pulling from a Git repository, Git will
automatically merge two branches (your repository and the public repository).
Consider the situation where we need to create a branch. The following commands
Imagine the situation where we need to create a branch. The following commands
will create a branch of the master branch, commit some changes in both branches
and then merging the two branches. In this after the merge, only master branch
is available.
and then merge the two branches. In this example after the merge, only the
``master'' branch is available.
\begin{verbatim}
$ git branch
......@@ -559,6 +561,77 @@ Finished one cherry-pick.
create mode 100644 def.txt
\end{verbatim}
You can also pick multiple commits, for example, by using \texttt{git
cherry-pick master\~{}4 master\~{}2} (two tildes). This will apply the changes
introduced by the fifth and third last commits pointed to by master and create 2
new commits with these changes. And it is possible to give a range: \texttt{git
rev-list --reverse master -- README | git cherry-pick -n --stdin}. This will
apply the changes introduced by all commits on the master branch that touched
\texttt{README} to the working tree and index. Notice the \texttt{-n} flag, so
the result can be inspected and made into a single new commit if suitable.
% }}}
\subsection{Hooks in Git} % {{{
\label{sub:hooks-in-git}
All hooks are stored in your \texttt{.git}-directory, and saved as
\texttt{.git/hooks/HOOKNAME}, where \texttt{HOOKNAME} is in
$\{$\texttt{applypatch-msg}, \texttt{commit-msg}, \texttt{post-commit},
\texttt{post-receive}, \texttt{post-update}, \texttt{pre-applypatch},
\texttt{pre-commit}, \texttt{prepare-commit-msg}, \texttt{pre-rebase},
\texttt{update}$\}$. Example hooks (\texttt{*.sample}) can be found in the
hooks-directory in your \texttt{.git}-directory.
I'll demonstrate the use of a \texttt{pre-commit} hook. This hook is invoked by
'git-commit', and can be bypassed with the \texttt{--no-verify} option. It takes
no parameter, and is invoked before obtaining the proposed commit log message
and making a commit. Exiting with non-zero status from this script causes the
'git-commit' to abort. Aborting on a non-zero status enables a developer to run,
for example, a set of test cases before committing to the ``main'' Git server
(if you're working with a team of developers). In this example hook for
pre-commit, I'll check if the file \texttt{conflict.txt} contains the
(sub)string \texttt{abc}.
\begin{verbatim}
$ cat <<EOF > /tmp/uva-git/a/.git/hooks/pre-commit
#!/bin/bash
[ ! -f Makefile ] || make
EOF
$ chmod +x /tmp/uva-git/a/.git/hooks/pre-commit
$ cat <<EOF > /tmp/uva-git/a/Makefile
all:
$(printf '\t')grep abc conflict.txt
EOF
$ git add Makefile && git commit -m "Added example Makefile."
[master 78f6e33] Added example Makefile.
1 files changed, 2 insertions(+), 0 deletions(-)
create mode 100644 Makefile
$ git pull && git push
$ echo "wrong" > conflict.txt
$ git commit -am "Added 'wrong' text to 'conflict.txt'"
grep abc conflict.txt
make: *** [all] Error 1
\end{verbatim}
\noindent The pre-commit hook works as expected (since \texttt{abc} is not found
in conflict.txt due to the commit). Now, I'll demonstrate forcing the commit,
which will bypass the pre-commit hook:
\begin{verbatim}
$ git commit --no-verify -am "Added 'wrong' text to 'conflict' (forced)"
[master 9fc290e] Added 'wrong' text to 'conflict' (forced)
1 files changed, 1 insertions(+), 1 deletions(-)
\end{verbatim}
\noindent Although the used check (\texttt{grep abc conflict.txt}) in the
example Makefile is pretty useless, the example clearly shows the possibilities
of a pre-commit hook. In this example, I also used here strings (\texttt{<<EOF}
and \texttt{EOF}) to show what data is stored in which file. Here strings allows
a user to paste file content to a file without the need to escape all bash-related
built-in commands (since escaping is normally required to prevent bash from
performing shell expansion).
% }}}
% }}}
......
simmod/ass1/Makefile deleted 100644 → 0
View file @ 1833f32e
FLAGS=-Wall -Wextra -std=c99 -pedantic
all: fp speed
speed: speed.o
gcc $(FLAGS) -o $@ $^
fp: floating_point.o
gcc $(FLAGS) -o $@ $^
%.o: %.c
gcc $(FLAGS) -o $@ -c $^
simmod/ass1/speed.c deleted 100644 → 0
View file @ 1833f32e
#include <stdlib.h>
#include <stdio.h>
int main(void) {
int i;
for(i=0; i < 1e9; i++);
printf("i = %d\n", i);
return 0;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment