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

cfbolz at codespeak.net cfbolz at codespeak.net
Thu Oct 14 17:24:52 CEST 2010

Author: cfbolz
Date: Thu Oct 14 17:24:50 2010
New Revision: 77943

mention self

Modified: pypy/extradoc/talk/pepm2011/paper.bib
--- pypy/extradoc/talk/pepm2011/paper.bib	(original)
+++ pypy/extradoc/talk/pepm2011/paper.bib	Thu Oct 14 17:24:50 2010
@@ -296,6 +296,19 @@
 	pages = {144--153}
+ at article{chambers_efficient_1989,
+	title = {An efficient implementation of {SELF} a dynamically-typed object-oriented language based on prototypes},
+	volume = {24},
+	url = {http://portal.acm.org/citation.cfm?id=74884},
+	doi = {10.1145/74878.74884},
+	abstract = {We have developed and implemented techniques that double the performance of dynamically-typed object-oriented languages. Our {SELF} implementation runs twice as fast as the fastest Smalltalk implementation, despite {SELF's} lack of classes and explicit variables. To compensate for the absence of classes, our system uses implementation-level maps to transparently group objects cloned from the same prototype, providing data type information and eliminating the apparent space overhead for prototype-based systems. To compensate for dynamic typing, user-defined control structures, and the lack of explicit variables, our system dynamically compiles multiple versions of a source method, each customized according to its receiver's map. Within each version the type of the receiver is fixed, and thus the compiler can statically bind and inline all messages sent to self. Message splitting and type prediction extract and preserve even more static type information, allowing the compiler to inline many other messages. Inlining dramatically improves performance and eliminates the need to hard-wire low-level methods such as +,==, and {ifTrue:.} Despite inlining and other optimizations, our system still supports interactive programming environments. The system traverses internal dependency lists to invalidate all compiled methods affected by a programming change. The debugger reconstructs inlined stack frames from compiler-generated debugging information, making inlining invisible to the {SELF} programmer.},
+	number = {10},
+	journal = {{SIGPLAN} Not.},
+	author = {C. Chambers and D. Ungar and E. Lee},
+	year = {1989},
+	pages = {49--70},
 	address = {Verona, Italy},
 	title = {Representation-based just-in-time specialization and the Psyco prototype for Python},

Modified: pypy/extradoc/talk/pepm2011/paper.tex
--- pypy/extradoc/talk/pepm2011/paper.tex	(original)
+++ pypy/extradoc/talk/pepm2011/paper.tex	Thu Oct 14 17:24:50 2010
@@ -1123,6 +1123,13 @@
 PyPy's JIT can be seen as some successor of Psyco for a general context (one of
 the authors of this paper is the author of Psyco).
+The original SELF JIT compiler \cite{chambers_efficient_1989} used an algorithm for
+forward-propagating the types of variables as part of its optimizations. This
+makes it possible to remove all type checks on a variable but the first one.
+The optimization does not deal with removing the full object, if it is
+short-lived, but the type check removals are similar to what our optimization
 partial evaluation:
@@ -1134,8 +1141,6 @@
 xxx: relation to compile-time garbage collection \cite{mazur_practical_2001};  separation logic; John Hughes: type specialization
-XXX cite SELF paper for the type propagation effects

More information about the Pypy-commit mailing list