arigo at codespeak.net arigo at codespeak.net
Fri Apr 3 15:56:23 CEST 2009

Author: arigo
Date: Fri Apr  3 15:56:20 2009
New Revision: 63565

Modified:
Log:
Typos.

==============================================================================
+++ pypy/extradoc/talk/icooolps2009-dotnet/intro.tex	Fri Apr  3 15:56:20 2009
@@ -50,7 +50,7 @@
during the translation process are all represented by a collection of control flow graphs,
at several levels of abstractions.

-Finally, the low-level control flow-graphs produced by the toolchain
+Finally, the low-level control flow graphs produced by the toolchain
can be translated to executable code for a specific platform by a
corresponding backend.
Currently, three fully developed backends are available to produce
@@ -144,7 +144,7 @@
The new generated code is potentially different for each run-time value seen.
This implies that the generated code needs to contain some sort of updatable
switch, or \emph{flexswitch}, which can pick the right code path based on the
-run-time value.  Typically, the value we switch on is the runtime dynamc type
+run-time value.  Typically, the value we switch on is the runtime dynamic type
of a value, so that the JIT compiler has all information needed to produce
very good code for that specific case.

==============================================================================
+++ pypy/extradoc/talk/icooolps2009-dotnet/paper.tex	Fri Apr  3 15:56:20 2009
@@ -77,7 +77,7 @@
\begin{abstract}
The CLI, i.e. the virtual machine at the core of the .NET environment, is a
statically typed virtual machine.  Although it is being used as a target for
-many different languages, it is hard to provide higly efficient implementation
+many different languages, it is hard to provide highly efficient implementation
of languages whose model is too different than the one of the VM.  In
particular, dynamically typed languages are typically order of magnitude
slower than, e.g., C\#.
@@ -92,10 +92,10 @@
infrastructure, by focusing on JIT compilation for .NET.

JIT compilation for .NET means to generate .NET bytecode at runtime, which
-will further compiled down to machine code by .NET's own JIT compiler.  The
+will be further compiled down to machine code by .NET's own JIT compiler.  The
main and novel contribution of this paper is to show that this
\emph{two-layers JIT} technique is effective, and can give very high speedups,
-up to make dynamic languages faster than C\# itself under certain
+up to making dynamic languages faster than C\# itself under certain
circumstances.

The practicality of the approach is demonstrated by showing some promising