Author: Carl Friedrich Bolz <[email protected]>
Branch: extradoc
Changeset: r4695:d65f43f09d93
Date: 2012-08-17 18:17 +0200
http://bitbucket.org/pypy/extradoc/changeset/d65f43f09d93/
Log: reorder the benchmark descriptions to be like in the diagrams
diff --git a/talk/dls2012/paper.tex b/talk/dls2012/paper.tex
--- a/talk/dls2012/paper.tex
+++ b/talk/dls2012/paper.tex
@@ -980,26 +980,6 @@
The benchmarks are
\begin{itemize}
-\item {\bf sqrt}$\left(T\right)$: approximates the square root of $y$. The
approximation is
-initialized to $x_0=y/2$ and the benchmark consists of a single loop updating
this
-approximation using $x_i = \left( x_{i-1} + y/x_{i-1} \right) / 2$ for $1\leq
i < 10^8$.
-Only the latest calculated value $x_i$ is kept alive as a local variable
within the loop.
-There are three different versions of this benchmark where $x_i$
- is represented with different type $T$ of objects: int's, float's and
- Fix16's. The latter, Fix16, is a custom class that implements
- fixpoint arithmetic with 16 bits precision. In Python and Lua there is only
- a single implementation of the benchmark that gets specialized
- depending on the class of it's input argument, $y$. In C,
- there are three different implementations.
-
-The Fix16 type is a custom class with operator overloading in Lua and Python.
-The C version uses a C++ class. The goal of this variant of the benchmark is to
-check how large the overhead of a custom arithmetic class is, compared to
-builtin data types.
-
-In Lua there is no direct support for
-integers so the int version is not provided.
-
\item {\bf conv3}$\left(n\right)$: one-dimensional convolution with fixed
kernel-size $3$. A single loop
is used to calculate a vector ${\bf b} = \left(b_1, \cdots, b_{n-2}\right)$
from a vector
${\bf a} = \left(a_1, \cdots, a_n\right)$ and a kernel ${\bf k} = \left(k_1,
k_2, k_3\right)$ using
@@ -1048,6 +1028,27 @@
magnitude calculation are combined in the implementation of this benchmark and
calculated in a single pass over
the input image. This single pass consists of two nested loops with a somewhat
larger amount of calculations
performed each iteration as compared to the other benchmarks.
+
+\item {\bf sqrt}$\left(T\right)$: approximates the square root of $y$. The
approximation is
+initialized to $x_0=y/2$ and the benchmark consists of a single loop updating
this
+approximation using $x_i = \left( x_{i-1} + y/x_{i-1} \right) / 2$ for $1\leq
i < 10^8$.
+Only the latest calculated value $x_i$ is kept alive as a local variable
within the loop.
+There are three different versions of this benchmark where $x_i$
+ is represented with different type $T$ of objects: int's, float's and
+ Fix16's. The latter, Fix16, is a custom class that implements
+ fixpoint arithmetic with 16 bits precision. In Python and Lua there is only
+ a single implementation of the benchmark that gets specialized
+ depending on the class of it's input argument, $y$. In C,
+ there are three different implementations.
+
+The Fix16 type is a custom class with operator overloading in Lua and Python.
+The C version uses a C++ class. The goal of this variant of the benchmark is to
+check how large the overhead of a custom arithmetic class is, compared to
+builtin data types.
+
+In Lua there is no direct support for
+integers so the int version is not provided.
+
\end{itemize}
The sobel and conv3x3 benchmarks are implemented
@@ -1070,14 +1071,14 @@
SciMark consists of:
\begin{itemize}
+\item {\bf FFT}$\left(n, c\right)$: Fast Fourier Transform of a vector with
$n$ elements, represented as an array, repeated $c$ times.
+\item {\bf LU}$\left(n, c\right)$: LU factorization of an $n \times n$ matrix.
The rows of the matrix is shuffled which makes the previously used
two-dimensional array class unsuitable. Instead a list of arrays is used to
represent the matrix. The calculation is repeated $c$ times.
+\item {\bf MonteCarlo}$\left(n\right)$: Monte Carlo integration by generating
$n$ points uniformly distributed over the unit square and computing the ratio
of those within the unit circle.
\item {\bf SOR}$\left(n, c\right)$: Jacobi successive over-relaxation on a
$n\times n$ grid repreated $c$ times.
The same custom two-dimensional array class as described above is used to
represent
the grid.
\item {\bf SparseMatMult}$\left(n, z, c\right)$: Matrix multiplication between
a $n\times n$ sparse matrix,
stored in compressed-row format, and a full storage vector, stored in a normal
array. The matrix has $z$ non-zero elements and the calculation is repeated $c$
times.
-\item {\bf MonteCarlo}$\left(n\right)$: Monte Carlo integration by generating
$n$ points uniformly distributed over the unit square and computing the ratio
of those within the unit circle.
-\item {\bf LU}$\left(n, c\right)$: LU factorization of an $n \times n$ matrix.
The rows of the matrix is shuffled which makes the previously used
two-dimensional array class unsuitable. Instead a list of arrays is used to
represent the matrix. The calculation is repeated $c$ times.
-\item {\bf FFT}$\left(n, c\right)$: Fast Fourier Transform of a vector with
$n$ elements, represented as an array, repeated $c$ times.
\end{itemize}
Benchmarks were run on Intel Xeon X5680 @3.33GHz with 12M cache and 16G of RAM
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
