[pypy-commit] extradoc extradoc: merge

[fijal]

Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: extradoc
Changeset: r3725:a226b2cf5659
Date: 2011-06-17 09:25 +0200
http://bitbucket.org/pypy/extradoc/changeset/a226b2cf5659/

Log:	merge

diff --git a/talk/ep2011/talk/talk.rst b/talk/ep2011/talk/talk.rst
--- a/talk/ep2011/talk/talk.rst
+++ b/talk/ep2011/talk/talk.rst
@@ -156,8 +156,24 @@
 Real world use case (2)
 -----------------------
 
-XXX write slide about this, the site is down ATM
-http://www.myhdl.org/doku.php/performance
+* **MyHDL**: VHDL-like language written in Python
+
+  - |scriptsize| http://www.myhdl.org/doku.php/performance |end_scriptsize|
+
+  - (now) competitive with "real world" VHDL and Verilog simulators
+
+
+|pause|
+
+|example<| ``myhdl.org`` |>|
+|small|
+
+  [...] the results are spectacular. By simply using a different interpreter,
+  our simulations run 6 to 12 times faster.
+
+|end_small|
+|end_example|
+
 
 
 Real world use case (3)
diff --git a/talk/iwtc11/benchmarks/sqrt/sqrt_fix16.c b/talk/iwtc11/benchmarks/sqrt/sqrt_fix16.c
--- a/talk/iwtc11/benchmarks/sqrt/sqrt_fix16.c
+++ b/talk/iwtc11/benchmarks/sqrt/sqrt_fix16.c
@@ -1,12 +1,12 @@
 #include <stdio.h>
 
 int main() {
-  long y = 1234 << 16;
+  long y = 123 << 16;
   long x = y / 2;
   long n = 100000000;
   while (n>0) {
     n -= 1;
-    x = ((x + (y << 16)/x)) / 2;
+    x = ((x + (y << 8)/(x >> 8))) / 2;
   }
   printf("%f\n", ((double) x) / ((double) (1<<16)));
   fprintf(stderr, "sqrt(Fix16):   ");
diff --git a/talk/iwtc11/paper.tex b/talk/iwtc11/paper.tex
--- a/talk/iwtc11/paper.tex
+++ b/talk/iwtc11/paper.tex
@@ -121,7 +121,19 @@
 \maketitle
 
 \begin{abstract}
-This is the text of the abstract.
+By introducing loop peeling into the optimization step of a tracing
+jit the effect of optimizations already in place will be increased
+greatly. Not only will they become able to move loop invariant code
+out of loop. They will also become able to reuse results from the
+previous iteration. Also, the implementation of excising optimizations
+can be left almost intact as they will not have to interact much with
+the loop peeling.
+
+Several benchmarks, with few guard failures, executed on the
+PyPy python JIT show over 2 
+times increase in speed when loop peeling was introduced. This makes
+some of them almost match optimized C performance and become over XXX
+times faster than cpython.
 \end{abstract}
 
 \category{D.3.4}{Programming Languages}{Processors}[code generation,