[pypy-dev] Question on the future of RPython

Paolo Giarrusso p.giarrusso at gmail.com
Thu Sep 30 08:33:02 CEST 2010


On Thu, Sep 30, 2010 at 03:21, Terrence Cole
<list-sink at trainedmonkeystudios.org> wrote:
> On Wed, 2010-09-29 at 23:50 +0200, Paolo Giarrusso wrote:

> I think it makes sense to treat the sorts of optimizations you can do
> with static analysis of a dynamic language with the same sort of guarded
> optimism that is used in pypy's jit compiler: run with the assumption
> that it will all work out, but watch for failure and fallback to a safe
> slow-path nicely when things go off the rails.

Agreed, but "watch out for failure" is done by guards, and one of the
further advantages of type inference, on top of "type feedback",
described there, is being able to remove some of those guards, because
that might help in some inner loops.
In some cases, that's still possible, by "watching out" not during
code execution but during execution of infrequent events. In Java
loading a class might invalidate some optimization assumptions (like
"this class has no subclass", useful for inlining without guards), but
that's checked by the classloading fast-path.

Same things could apply to allow Python cross-module type-inferencing.
I don't know exactly how modules at JIT compile-time and runtime can
be different, but I guess that invalidation at module loading should
catch that. And invalidate lots of compiled code, which is usually
fine. The interaction of this with tracing is actually interesting: in
a Python tracing JIT, you could keep the traces and restore omitted
guards, but when your JIT traces the Python interpreter, I wonder how
do you express any of this. One can insert a guard only if needed, but
telling "hey, this is invalid" requires some special API.

My proposal, here, would be a "virtual guard", which is recorded in
the guard but omitted from the output. The "omission" is what can be
invalidated, but the trace itself (not its compiled version) is kept
(because it can still be executed).
If some form of this makes actually sense (I've just thought on it 5
minutes), this is something worth publishing, which would allow me to
take some time of my PhD to work on it - if it's not already done by
papers on tracing JITs.
-- 
Paolo Giarrusso - Ph.D. Student
http://www.informatik.uni-marburg.de/~pgiarrusso/



More information about the Pypy-dev mailing list