[pypy-svn] r77932 - pypy/extradoc/talk/pepm2011

pedronis at codespeak.net pedronis at codespeak.net
Thu Oct 14 15:27:08 CEST 2010


Author: pedronis
Date: Thu Oct 14 15:27:07 2010
New Revision: 77932

Modified:
   pypy/extradoc/talk/pepm2011/paper.tex
Log:
expand for clarification

Modified: pypy/extradoc/talk/pepm2011/paper.tex
==============================================================================
--- pypy/extradoc/talk/pepm2011/paper.tex	(original)
+++ pypy/extradoc/talk/pepm2011/paper.tex	Thu Oct 14 15:27:07 2010
@@ -928,27 +928,30 @@
 
 \cfbolz{probably can be cut in case of space problems}
 
-One problem to the successful application of the allocation removal techniques
-described in the previous sections is the presence of frame-introspection
-features in many dynamic languages. Languages such as Python and Smalltalk allow
-the programmer to get access to the frames object that the interpreter uses to
-store local variables. This is a useful feature, as makes the implementation of
-a debugger possible in Python without needing much support from the VM level. On
-the other hand, it severely hinders the effectiveness of allocation removal,
-because every time an object is stored into a local variable, it is stored into
-the frame-object, which makes it escape.
-
-XXX [fijal] Well, in fact that's *a lot* of support for debugger from the VM.
-The support is just generic instead of specific.
-
-This problem is solved by making it possible to the interpreter author to add
-some hints into the source code to declare instances of one class as frame
-objects. The JIT will then fill these objects only lazily when they are actually
-accessed (\eg because a debugger is used). Therefore in the common case, nothing
-is stored into the frame objects, making the problem of too much escaping go
-away. This is a common approach in VM implementations \cite{miranda_context_1999}, the only
-novelty in our approach lays in its generality, because most other JITs are just
-specifically written for one particular language.
+One problem to the successful application of the allocation removal
+techniques described in the previous sections is the presence of
+frame-introspection features in many dynamic languages. Languages such
+as Python and Smalltalk allow the programmer to get access to the
+frames object that the interpreter uses to store local variables. This
+is a useful feature, as makes the implementation of a debugger
+possible in Python without needing much explicit support from the VM
+level. On the other hand, it severely hinders the effectiveness of
+allocation removal, because every time an object is stored into a
+local variable, it is stored into the frame-object, which makes it
+escape.
+
+This problem is solved by making it possible to the interpreter author
+to add some hints into the source code to declare instances of one
+class as frame objects needing special treatment. The JIT will then
+fill these objects only lazily when they are actually accessed (\eg
+because a debugger is used) using values from JIT-emitted code runtime
+locations (typically the CPU stack). Therefore in the common case,
+nothing is stored into the frame objects, making the problem of too
+much escaping go away. This is a common approach in VM implementations
+\cite{miranda_context_1999}, the only novelty in our approach lays in
+its generality, all the delicate support code for this is generated, because
+most other JITs are just specifically written for one particular
+language.
 
 % subsection Virtualizables (end)
 



More information about the Pypy-commit mailing list