[pypy-svn] r63404 - pypy/branch/pyjitpl5-simplify/pypy/jit/metainterp/doc
arigo at codespeak.net
arigo at codespeak.net
Sat Mar 28 14:11:38 CET 2009
Date: Sat Mar 28 14:11:37 2009
New Revision: 63404
The overall approach starts to get clearer.
--- pypy/branch/pyjitpl5-simplify/pypy/jit/metainterp/doc/loop.txt (original)
+++ pypy/branch/pyjitpl5-simplify/pypy/jit/metainterp/doc/loop.txt Sat Mar 28 14:11:37 2009
@@ -8,20 +8,15 @@
*Loop Tree* = tree of operations. Its root (i.e. start) corresponds to
a ``can_enter_jit`` marker, so it is when an application-level loop was
-closed. Its branches end in a JUMP back, corresponding to closing the
-application-level loop. The JUMPs themselves may go to the same or to
-another loop tree, but for now we assume that all loop trees connected
-in this way correspond to the same application-level loop.
+closed. Its branches end in a JUMP going either back to the head of the
+same loop tree, or to the head of another one.
-We use Perfect Specialization to find out exactly how specialized each
-loop should be.
-In theory, Perfect Specialization of a complete tree means the
+In theory, Perfect Specialization of a sequence of operations forming a
+loop means the following:
* find how much of the input arguments' structure is needed;
* find how much structure the output arguments have;
@@ -67,3 +62,35 @@
* in other cases, the result is ``FixedClassSpec`` if the two specnodes
have the same class, or ``NotSpec`` if any is a ``NotSpec`` or if the
two classes differ.
+1. when we interpret normally and see a ``can_enter_jit`` marker often
+2. or when a guard in the running machine code fails often enough.
+Stop tracing when we encounter the next ``can_enter_jit``.
+Call "the loop" the sequence of instructions from the old
+``can_enter_jit`` to the new one. In the case 2 above, this means that
+we must insert into the loop all unoptimized operations that go before
+the guard failure; this is necessary to see a complete loop.
+Apply Perfect Specialization to the loop.
+Case A: We are seeing a new loop header (i.e. we did not see before this
+combination of specnodes at this bytecode position). Compile the new
+loop completely, and jump to it.
+Case B: We get the same specnodes as a previously-compiled loop (which
+may be the same loop as the one we started with, or not). Compile only
+a bridge, going from the guard failure to the new loop head. If we were
+in case 1 above, the "guard failure" is actually the start from the
+interpreter; so this combination of cases means compile a bridge going
+efficiently from the interpreter (with no specialization) to the loop
+in machine code (with specialization).
More information about the Pypy-commit