[pypy-svn] r60625 - pypy/extradoc/talk/ecoop2009

cfbolz at codespeak.net cfbolz at codespeak.net
Fri Dec 19 21:38:23 CET 2008

Author: cfbolz
Date: Fri Dec 19 21:38:21 2008
New Revision: 60625

add material to the related work section, needs an overhaul

Modified: pypy/extradoc/talk/ecoop2009/conclusion.tex
--- pypy/extradoc/talk/ecoop2009/conclusion.tex	(original)
+++ pypy/extradoc/talk/ecoop2009/conclusion.tex	Fri Dec 19 21:38:21 2008
@@ -1,6 +1,59 @@
 \section{Related Word}
-XXX add me
+Promotion is a concept that we have already explored in other contexts. Psyco is
+a run-time specialiser for Python that uses promotion (called ``unlift'' in
+\cite{DBLP:conf/pepm/Rigo04}). However, Psyco is a manually written JIT, is
+not applicable to other languages and cannot be retargetted.
+ - reference standard jit stuff, PICs \cite{hoelzle_optimizing_1991}, this one: http://www.cs.ucsb.edu/~urs/oocsb/self/papers/type-feedback.html
+ - compare against tracing JITs \cite{gal_hotpathvm_2006}. tracing jits make
+ implementing jits much easier, maybe less need for JIT generation. also, they
+ concentrate on loops, which makes them produce a lot less code (which will need
+ to be addressed in our work as well).
+ so far tracing JITs have less general allocation removal techniques, which
+ makes them get less speedup in a dynamic language with boxing
+in my master I had this snippet:
+The generated code typically contains guards; in recent research
+\cite{gal_incremental_2006} on Java, these guards' behaviour is extended to be
+similar to our promotion.  This has been used twice to implement a dynamic
+language (JavaScript), by Tamarin\footnote{{\tt
+http://www.mozilla.org/projects/tamarin/}} and in \cite{chang_efficient_2007}.
+There has been an enormous amount of work on partial evaluation for compiler
+generation. A good introduction is given in \cite{Jones:peval}. However, most of
+it is for generating ahead-of-time compilers, which cannot produce very good
+performance results for dynamic languages.
+However, there is also some research on runtime partial evaluation. One of the
+earliest examples is Tempo for C
+\cite{DBLP:conf/popl/ConselN96,DBLP:conf/dagstuhl/ConselHNNV96}. However, it is
+essentially an offline specializer ``packaged as a library''; decisions about
+what can be specialized and how are pre-determined.
+Another work in this direction is DyC \cite{grant_dyc_2000}, another runtime
+specializer for C.  Specialization decisions are also pre-determined, but
+``polyvariant program-point specialization'' gives a coarse-grained equivalent
+of our promotion.  Targeting the C language makes higher-level specialization
+difficult, though (e.g.\ \texttt{mallocs} are not removed).
+Greg Sullivan introduced "Dynamic Partial Evaluation", which is a special
+form of partial evaluation at runtime \cite{sullivan_dynamic_2001} and describes
+an implementation for a small dynamic language based on lambda calculus. This
+work is conceptually very close to our own.
+% XXX there are no performance figures, we have no clue how much of this is
+% implemented. not sure how to write this
+ - apart from that we maybe should talk about escape analysis
+ \cite{Blanchet99escapeanalysis}, \cite{Choi99escapeanalysis}
+ our algorithm is totally simple-minded in comparison, but is useful in practise
 XXX add me

Modified: pypy/extradoc/talk/ecoop2009/main.bbl
--- pypy/extradoc/talk/ecoop2009/main.bbl	(original)
+++ pypy/extradoc/talk/ecoop2009/main.bbl	Fri Dec 19 21:38:21 2008
@@ -1,4 +1,4 @@
 D.~Ancona, M.~Ancona, A~Cuni, and N.~Matsakis.
@@ -17,11 +17,50 @@
   Revised Selected Papers}, volume 5146 of {\em Lecture Notes in Computer
   Science}, pages 123--139, 2008.
+Mason Chang, Michael Bebenita, Alexander Yermolovich, Andreas Gal, and Michael
+  Franz.
+\newblock Efficient just-in-time execution of dynamically typed languages via
+  code specialization using precise runtime type inference.
+\newblock Technical report, Donald Bren School of Information and Computer
+  Science, University of California, Irvine, 2007.
+Charles Consel, Luke Hornof, Fran\c{c}ois No{\"e}l, Jacques Noy{\'e}, and
+  Nicolae Volansche.
+\newblock A uniform approach for compile-time and run-time specialization.
+\newblock In {\em Dagstuhl Seminar on Partial Evaluation}, pages 54--72, 1996.
+Charles Consel and Fran\c{c}ois No{\"e}l.
+\newblock A general approach for run-time specialization and its application to
+  {C}.
+\newblock In {\em POPL}, pages 145--156, 1996.
 Yoshihiko Futamura.
 \newblock Partial evaluation of computation process, revisited.
 \newblock {\em Higher Order Symbol. Comput.}, 12(4):377--380, 1999.
+Andreas Gal and Michael Franz.
+\newblock Incremental dynamic code generation with trace trees.
+\newblock Technical report, Donald Bren School of Information and Computer
+  Science, University of California, Irvine, November 2006.
+Andreas Gal, Christian~W. Probst, and Michael Franz.
+\newblock {HotpathVM}: an effective {JIT} compiler for resource-constrained
+  devices.
+\newblock In {\em Proceedings of the 2nd international conference on Virtual
+  execution environments}, pages 144--153, Ottawa, Ontario, Canada, 2006. ACM.
+Brian Grant, Markus Mock, Matthai Philipose, Craig Chambers, and Susan~J.
+  Eggers.
+\newblock {DyC}: an expressive annotation-directed dynamic compiler for {C}.
+\newblock {\em Theoretical Computer Science}, 248:147--199, 2000.
 Urs H{\"o}lzle, Craig Chambers, and David Ungar.
 \newblock Optimizing dynamically-typed object-oriented languages with
@@ -29,9 +68,26 @@
 \newblock In {\em Proceedings of the European Conference on Object-Oriented
   Programming}, pages 21--38. Springer-Verlag, 1991.
+Neil~D. Jones, Carsten~K. Gomard, and Peter Sestoft.
+\newblock {\em Partial Evaluation and Automatic Program Generation}.
+\newblock Prentice Hall, 1993.
 A.~Rigo and S.~Pedroni.
 \newblock Py{P}y's approach to virtual machine construction.
 \newblock In {\em OOPSLA Companion}, pages 944--953, 2006.
+Armin Rigo.
+\newblock Representation-based just-in-time specialization and the psyco
+  prototype for python.
+\newblock In {\em PEPM}, pages 15--26, 2004.
+Gregory~T. Sullivan.
+\newblock Dynamic partial evaluation.
+\newblock In {\em Proceedings of the Second Symposium on Programs as Data
+  Objects}, pages 238--256. Springer-Verlag, 2001.

Modified: pypy/extradoc/talk/ecoop2009/main.bib
--- pypy/extradoc/talk/ecoop2009/main.bib	(original)
+++ pypy/extradoc/talk/ecoop2009/main.bib	Fri Dec 19 21:38:21 2008
@@ -68,4 +68,99 @@
    year =      1993,
+ at inproceedings{DBLP:conf/pepm/Rigo04,
+  author    = {Armin Rigo},
+  title     = {Representation-based just-in-time specialization and the
+               psyco prototype for python},
+  booktitle = {PEPM},
+  year      = {2004},
+  pages     = {15-26},
+  ee        = {http://doi.acm.org/10.1145/1014007.1014010},
+  bibsource = {DBLP, http://dblp.uni-trier.de}
+ at inproceedings{gal_hotpathvm_2006,
+	address = {Ottawa, Ontario, Canada},
+	title = {{HotpathVM}: an effective {JIT} compiler for resource-constrained devices},
+	isbn = {1-59593-332-6},
+	url = {http://portal.acm.org/citation.cfm?doid=1134760.1134780},
+	doi = {10.1145/1134760.1134780},
+	abstract = {We present a just-in-time compiler for a Java VM that is small enough to fit on resource-constrained devices, yet is surprisingly effective. Our system dynamically identifies traces of frequently executed bytecode instructions (which may span several basic blocks across several methods) and compiles them via Static Single Assignment (SSA) construction. Our novel use of SSA form in this context allows to hoist instructions across trace side-exits without necessitating expensive compensation code in off-trace paths. The overall memory consumption (code and data) of our system is only 150 kBytes, yet benchmarks show a speedup that in some cases rivals heavy-weight just-in-time compilers.},
+	booktitle = {Proceedings of the 2nd international conference on Virtual execution environments},
+	publisher = {ACM},
+	author = {Andreas Gal and Christian W. Probst and Michael Franz},
+	year = {2006},
+	keywords = {dynamic compilation,embedded and resource-constrained systems,mixed-mode interpretive compiled systems,software trace scheduling,static single assignment form,virtual machines},
+	pages = {144-153}
+ at techreport{gal_incremental_2006,
+	title = {Incremental Dynamic Code Generation with Trace Trees},
+	abstract = {The unit of compilation for traditional just-in-time compilers is the method. We have explored trace-based compilation, in which the unit of compilation is a loop, potentially spanning multiple methods and even library code. Using a new intermediate representation that is discovered and updated lazily on-demand while the program is being executed, our compiler generates code that is competitive with traditional dynamic compilers, but that uses only a fraction of the compile time and memory footprint.},
+	institution = {Donald Bren School of Information and Computer Science, University of California, Irvine},
+	author = {Andreas Gal and Michael Franz},
+	month = nov,
+	year = {2006},
+	pages = {11}
+ at techreport{chang_efficient_2007,
+	title = {Efficient Just-In-Time Execution of Dynamically Typed Languages
+Via Code Specialization Using Precise Runtime Type Inference},
+	abstract = {Dynamically typed languages such as JavaScript present a challenge to just-in-time compilers. In contrast to statically typed languages such as JVML, in which there are specific opcodes for common operations on primitive types (such as iadd for integer addition), all operations in dynamically typed language such as JavaScript are late-bound. Often enough, types cannot be inferred with certainty ahead of execution. As a result, just-in-time compilers for dynamically typed languages have tended to perform worse than their statically-typed counterparts. We present a new approach to compiling dynamically typed languages in which code traces observed during execution are dynamically specialized for each actually observed run-time type. For most benchmark programs, our prototype JavaScript virtual machine outperforms every other JavaScript platform known to us.},
+	institution = {Donald Bren School of Information and Computer Science, University of California, Irvine},
+	author = {Mason Chang and Michael Bebenita and Alexander Yermolovich and Andreas Gal and Michael Franz},
+	year = {2007},
+	keywords = {dynamic,javascript,JIT,traces}
+ at inproceedings{DBLP:conf/popl/ConselN96,
+  author    = {Charles Consel and
+               Fran\c{c}ois No{\"e}l},
+  title     = {A General Approach for Run-Time Specialization and its Application
+               to {C}},
+  booktitle = {POPL},
+  year      = {1996},
+  pages     = {145-156},
+  ee        = {http://doi.acm.org/10.1145/237721.237767},
+  bibsource = {DBLP, http://dblp.uni-trier.de}
+ at inproceedings{DBLP:conf/dagstuhl/ConselHNNV96,
+  author    = {Charles Consel and
+               Luke Hornof and
+               Fran\c{c}ois No{\"e}l and
+               Jacques Noy{\'e} and
+               Nicolae Volansche},
+  title     = {A Uniform Approach for Compile-Time and Run-Time Specialization},
+  booktitle = {Dagstuhl Seminar on Partial Evaluation},
+  year      = {1996},
+  pages     = {54-72},
+  bibsource = {DBLP, http://dblp.uni-trier.de}
+ at article{grant_dyc_2000,
+	title = {{DyC}: an expressive annotation-directed dynamic compiler for {C}},
+	volume = {248},
+	url = {http://citeseer.ist.psu.edu/grant97dyc.html},
+	journal = {Theoretical Computer Science},
+	author = {Brian Grant and Markus Mock and Matthai Philipose and Craig Chambers and Susan J. Eggers},
+	year = {2000},
+	keywords = {unread},
+	pages = {147-199}
+ at inproceedings{sullivan_dynamic_2001,
+	title = {Dynamic Partial Evaluation},
+	isbn = {3-540-42068-1},
+	url = {http://portal.acm.org/citation.cfm?id=668117},
+	booktitle = {Proceedings of the Second Symposium on Programs as Data Objects},
+	publisher = {Springer-Verlag},
+	author = {Gregory T. Sullivan},
+	year = {2001},
+	pages = {238-256}

More information about the Pypy-commit mailing list