Author: Carl Friedrich Bolz <[email protected]>
Branch: extradoc
Changeset: r4645:a882be7f918b
Date: 2012-08-16 19:55 +0200
http://bitbucket.org/pypy/extradoc/changeset/a882be7f918b/
Log: move stuff around
diff --git a/talk/dls2012/paper.tex b/talk/dls2012/paper.tex
--- a/talk/dls2012/paper.tex
+++ b/talk/dls2012/paper.tex
@@ -889,11 +889,19 @@
\section{Benchmarks}
-The loop peeling optimization was implemented in the PyPy
-framework in about 450 lines of RPython code. That means that the
JIT-compilers generated for all
+The loop peeling optimization was implemented in RPython's tracing JIT
+in about 450 lines of RPython code. That means that the JIT-compilers
generated for all
interpreters implemented with RPython now can take advantage of
it. Benchmarks have been executed for a few different interpreters and
-we see improvements in several cases. The ideal loop for this optimization
+we see improvements in several cases.
+
+An example of an RPython interpreter that is helped greatly by this
+optimization is our Prolog interpreter~\cite{bolz_towards_2010}. Prolog
+programs often contain tight loops that perform for example list processing.
+Furthermore we experimented with a Python library for writing numerical kernels
+doing array manipulation.
+
+The ideal loop for this optimization
is short and contains numerical calculations with no failing guards and no
external calls. Larger loops involving many operations on complex objects
typically benefit less from it. Loop peeling never makes the generated code
worse, in
@@ -962,7 +970,6 @@
specified.}
\end{figure*}
-\subsection{Python}
The Python interpreter of the RPython framework is a complete Python
version 2.7 compatible interpreter. A set of numerical
calculations were implemented in both Python, C and Lua and their
@@ -976,7 +983,7 @@
The benchmarks are
\begin{itemize}
\item {\bf sqrt}$\left(T\right)$: approximates the square root of $y$. The
approximation is
-initiated to $x_0=y/2$ and the benchmark consists of a single loop updating
this
+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$
@@ -1060,7 +1067,7 @@
\begin{itemize}
\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 gird.
+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.
@@ -1115,14 +1122,6 @@
even surpassing it. LuaJIT is generating machine code of higher quality because
it has a much better register allocator than PyPy, among other things.
-Other interesting interpreters that are helped greatly by this optimization are
-for example our Prolog interpreter written in
-RPython~\cite{bolz_towards_2010}. Prolog programs often contain
-tight
-loops that perform list processing. Furthermore we experimented with a Python
library
-for writing numerical kernels doing array manipulation. The exact extent is
-out of scope for this paper.
-
\section{Related Work}
\label{sec:related}
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
