[pypy-svn] r63532 - pypy/extradoc/talk/icooolps2009
cfbolz at codespeak.net
cfbolz at codespeak.net
Thu Apr 2 13:27:53 CEST 2009
Author: cfbolz
Date: Thu Apr 2 13:27:52 2009
New Revision: 63532
Modified:
pypy/extradoc/talk/icooolps2009/paper.bib
pypy/extradoc/talk/icooolps2009/paper.tex
Log:
Add more references (slightly too large diff, as the reference-file is
auto-generated).
Modified: pypy/extradoc/talk/icooolps2009/paper.bib
==============================================================================
--- pypy/extradoc/talk/icooolps2009/paper.bib (original)
+++ pypy/extradoc/talk/icooolps2009/paper.bib Thu Apr 2 13:27:52 2009
@@ -1,4 +1,54 @@
+ at inproceedings{ancona_rpython:step_2007,
+ address = {Montreal, Quebec, Canada},
+ title = {{RPython:} a step towards reconciling dynamically and statically typed {OO} languages},
+ isbn = {978-1-59593-868-8},
+ url = {http://portal.acm.org/citation.cfm?id=1297091},
+ doi = {10.1145/1297081.1297091},
+ abstract = {Although the C-based interpreter of Python is reasonably fast, implementations on the {CLI} or the {JVM} platforms offers some advantages in terms of robustness and interoperability. Unfortunately, because the {CLI} and {JVM} are primarily designed to execute statically typed, object-oriented languages, most dynamic language implementations cannot use the native bytecodes for common operations like method calls and exception handling; as a result, they are not able to take full advantage of the power offered by the {CLI} and {JVM.}},
+ booktitle = {Proceedings of the 2007 symposium on Dynamic languages},
+ publisher = {{ACM}},
+ author = {Davide Ancona and Massimo Ancona and Antonio Cuni and Nicholas D. Matsakis},
+ year = {2007},
+ pages = {53--64}
+},
+
+ at article{futamura_partial_1999,
+ title = {Partial Evaluation of Computation Process - An Approach to a {Compiler-Compiler}},
+ volume = {12},
+ url = {http://citeseer.ist.psu.edu/futamura99partial.html},
+ number = {4},
+ journal = {{Higher-Order} and Symbolic Computation},
+ author = {Yoshihiko Futamura},
+ year = {1999},
+ pages = {381--391},
+},
+
+ at book{jones_partial_1993,
+ title = {Partial evaluation and automatic program generation},
+ isbn = {0-13-020249-5},
+ url = {http://portal.acm.org/citation.cfm?id=153676},
+ abstract = {This book is out of print. For copies, Please refer to the following online page},
+ publisher = {{Prentice-Hall,} Inc.},
+ author = {Neil D. Jones and Carsten K. Gomard and Peter Sestoft},
+ year = {1993},
+ pages = {415}
+},
+
+ at inproceedings{rigo_pypys_2006,
+ address = {Portland, Oregon, {USA}},
+ title = {{PyPy's} approach to virtual machine construction},
+ isbn = {{1-59593-491-X}},
+ url = {http://portal.acm.org/citation.cfm?id=1176753},
+ doi = {10.1145/1176617.1176753},
+ abstract = {The {PyPy} project seeks to prove both on a research and a practical level the feasibility of constructing a virtual machine {(VM)} for a dynamic language in a dynamic language - in this case, Python. The aim is to translate (i.e. compile) the {VM} to arbitrary target environments, ranging in level from {C/Posix} to {Smalltalk/Squeak} via Java and {CLI/.NET,} while still being of reasonable efficiency within these {environments.A} key tool to achieve this goal is the systematic reuse of the Python language as a system programming language at various levels of our architecture and translation process. For each level, we design a corresponding type system and apply a generic type inference engine - for example, the garbage collector is written in a style that manipulates simulated pointer and address objects, and when translated to C these operations become C-level pointer and address instructions.},
+ booktitle = {Companion to the 21st {ACM} {SIGPLAN} conference on Object-oriented programming systems, languages, and applications},
+ publisher = {{ACM}},
+ author = {Armin Rigo and Samuele Pedroni},
+ year = {2006},
+ pages = {944--953}
+},
+
@techreport{miranda_context_1999,
title = {Context Management in {VisualWorks} 5i},
abstract = {Smalltalk-80 provides a reification of execution state in the form of context objects which represent procedure activation records. Smalltalk-80 also provides full closures with indefinite extent. These features pose interesting implementation challenges because a naïve implementation entails instantiating context objects on every method activation, but typical Smalltalk-80 programs obey stack discipline for the vast majority of activations. Both software and hardware implementations of Smalltalk-80 have mapped contexts and closure activations to stack frames but not without overhead when compared to traditional stack-based activation and return in “conventional” languages. We present a new design for contexts and closures that significantly reduces the overall overhead of these features and imposes overhead only in code that actually manipulates execution state in the form of contexts.},
@@ -7,34 +57,72 @@
year = {1999},
},
- at inproceedings{sullivan_dynamic_2003,
- address = {San Diego, California},
- title = {Dynamic native optimization of interpreters},
- isbn = {1-58113-655-2},
- url = {http://portal.acm.org/citation.cfm?id=858570.858576},
- doi = {10.1145/858570.858576},
- abstract = {For domain specific languages, "scripting languages", dynamic languages, and for virtual machine-based languages, the most straightforward implementation strategy is to write an interpreter. A simple interpreter consists of a loop that fetches the next bytecode, dispatches to the routine handling that bytecode, then loops. There are many ways to improve upon this simple mechanism, but as long as the execution of the program is driven by a representation of the program other than as a stream of native instructions, there will be some "interpretive {overhead".There} is a long history of approaches to removing interpretive overhead from programming language implementations. In practice, what often happens is that, once an interpreted language becomes popular, pressure builds to improve performance until eventually a project is undertaken to implement a native Just In Time {(JIT)} compiler for the language. Implementing a {JIT} is usually a large effort, affects a significant part of the existing language implementation, and adds a significant amount of code and complexity to the overall code {base.In} this paper, we present an innovative approach that dynamically removes much of the interpreted overhead from language implementations, with minimal instrumentation of the original interpreter. While it does not give the performance improvements of hand-crafted native compilers, our system provides an appealing point on the language implementation spectrum.},
- booktitle = {Proceedings of the 2003 workshop on Interpreters, virtual machines and emulators},
- publisher = {{ACM}},
- author = {Gregory T. Sullivan and Derek L. Bruening and Iris Baron and Timothy Garnett and Saman Amarasinghe},
- year = {2003},
- pages = {50--57},
+ at techreport{mason_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.},
+ number = {{ICS-TR-07-10}},
+ 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},
},
- at inbook{bolz_back_2008,
- title = {Back to the Future in One Week — Implementing a Smalltalk {VM} in {PyPy}},
- url = {http://dx.doi.org/10.1007/978-3-540-89275-5_7},
- abstract = {We report on our experiences with the Spy project, including implementation details and benchmark results. Spy is a re-implementation of the Squeak (i.e. Smalltalk-80) {VM} using the {PyPy} toolchain. The {PyPy} project allows code written in {RPython,} a subset of Python, to be translated
-to a multitude of different backends and architectures. During the translation, many aspects of the implementation can be
-independently tuned, such as the garbage collection algorithm or threading implementation. In this way, a whole host of interpreters
-can be derived from one abstract interpreter definition. Spy aims to bring these benefits to Squeak, allowing for greater portability and, eventually, improved performance. The current
-Spy codebase is able to run a small set of benchmarks that demonstrate performance superior to many similar Smalltalk {VMs,} but
-which still run slower than in Squeak itself. Spy was built from scratch over the course of a week during a joint {Squeak-PyPy} Sprint in Bern last autumn.
+ at article{grant_dyc:expressive_2000,
+ title = {{DyC:} an expressive annotation-directed dynamic compiler for C},
+ volume = {248},
+ url = {http://citeseer.ist.psu.edu/grant97dyc.html},
+ number = {1--2},
+ journal = {Theoretical Computer Science},
+ author = {Brian Grant and Markus Mock and Matthai Philipose and Craig Chambers and Susan J. Eggers},
+ year = {2000},
+ pages = {147--199}
},
- booktitle = {{Self-Sustaining} Systems},
- author = {Carl Friedrich Bolz and Adrian Kuhn and Adrian Lienhard and Nicholas Matsakis and Oscar Nierstrasz and Lukas Renggli and Armin Rigo and Toon Verwaest},
- year = {2008},
- pages = {123--139}
+
+ at article{bala_dynamo:transparent_2000,
+ title = {Dynamo: a transparent dynamic optimization system},
+ volume = {35},
+ url = {http://citeseer.ist.psu.edu/bala00dynamo.html},
+ number = {5},
+ journal = {{ACM} {SIG{\textbackslash}-PLAN} Notices},
+ author = {Vasanth Bala and Evelyn Duesterwald and Sanjeev Banerjia},
+ year = {2000},
+ pages = {1--12}
+},
+
+ at techreport{andreas_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.},
+ number = {{ICS-TR-06-16}},
+ 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 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}
+},
+
+ at inproceedings{gal_hotpathvm:effective_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},
+ pages = {144--153}
},
@inproceedings{hlzle_optimizing_1994,
@@ -51,25 +139,14 @@
pages = {326--336},
},
- at techreport{andreas_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.},
- number = {{ICS-TR-06-16}},
- 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{mason_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.},
- number = {{ICS-TR-07-10}},
- 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},
+ at article{consel_uniform_1996,
+ title = {A uniform approach for compile-time and run-time specialization},
+ url = {http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.103.248},
+ doi = {10.1.1.103.248},
+ journal = {{PARTIAL} {EVALUATION,} {INTERNATIONAL} {SEMINAR,} {DAGSTUHL} {CASTLE,} {NUMBER} 1110 {IN} {LECTURE} {NOTES} {IN} {COMPUTER} {SCIENCE}},
+ author = {Charles Consel and Luke Hornof and Francois Noel and Jacques Noye and Nicolae Volanschi and Universite De Rennes Irisa},
+ year = {1996},
+ pages = {54---72}
},
@inproceedings{andreas_gal_one_2007,
@@ -95,45 +172,6 @@
year = {2007}
},
- at inproceedings{rigo_pypys_2006,
- address = {Portland, Oregon, {USA}},
- title = {{PyPy's} approach to virtual machine construction},
- isbn = {{1-59593-491-X}},
- url = {http://portal.acm.org/citation.cfm?id=1176753},
- doi = {10.1145/1176617.1176753},
- abstract = {The {PyPy} project seeks to prove both on a research and a practical level the feasibility of constructing a virtual machine {(VM)} for a dynamic language in a dynamic language - in this case, Python. The aim is to translate (i.e. compile) the {VM} to arbitrary target environments, ranging in level from {C/Posix} to {Smalltalk/Squeak} via Java and {CLI/.NET,} while still being of reasonable efficiency within these {environments.A} key tool to achieve this goal is the systematic reuse of the Python language as a system programming language at various levels of our architecture and translation process. For each level, we design a corresponding type system and apply a generic type inference engine - for example, the garbage collector is written in a style that manipulates simulated pointer and address objects, and when translated to C these operations become C-level pointer and address instructions.},
- booktitle = {Companion to the 21st {ACM} {SIGPLAN} conference on Object-oriented programming systems, languages, and applications},
- publisher = {{ACM}},
- author = {Armin Rigo and Samuele Pedroni},
- year = {2006},
- pages = {944--953}
-},
-
- at article{bala_dynamo:transparent_2000,
- title = {Dynamo: a transparent dynamic optimization system},
- volume = {35},
- url = {http://citeseer.ist.psu.edu/bala00dynamo.html},
- number = {5},
- journal = {{ACM} {SIG{\textbackslash}-PLAN} Notices},
- author = {Vasanth Bala and Evelyn Duesterwald and Sanjeev Banerjia},
- year = {2000},
- pages = {1--12}
-},
-
- at inproceedings{gal_hotpathvm:effective_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},
- pages = {144--153}
-},
-
@inproceedings{hlzle_optimizing_1991,
title = {Optimizing {Dynamically-Typed} {Object-Oriented} Languages With Polymorphic Inline Caches},
isbn = {3-540-54262-0},
@@ -157,16 +195,57 @@
author = {Armin Rigo},
year = {2004},
pages = {15--26}
-}
+},
+
+ at inproceedings{sullivan_dynamic_2003,
+ address = {San Diego, California},
+ title = {Dynamic native optimization of interpreters},
+ isbn = {1-58113-655-2},
+ url = {http://portal.acm.org/citation.cfm?id=858570.858576},
+ doi = {10.1145/858570.858576},
+ abstract = {For domain specific languages, "scripting languages", dynamic languages, and for virtual machine-based languages, the most straightforward implementation strategy is to write an interpreter. A simple interpreter consists of a loop that fetches the next bytecode, dispatches to the routine handling that bytecode, then loops. There are many ways to improve upon this simple mechanism, but as long as the execution of the program is driven by a representation of the program other than as a stream of native instructions, there will be some "interpretive {overhead".There} is a long history of approaches to removing interpretive overhead from programming language implementations. In practice, what often happens is that, once an interpreted language becomes popular, pressure builds to improve performance until eventually a project is undertaken to implement a native Just In Time {(JIT)} compiler for the language. Implementing a {JIT} is usually a large effort, affects a significant part of the existing language implementation, and adds a significant amount of code and complexity to the overall code {base.In} this paper, we present an innovative approach that dynamically removes much of the interpreted overhead from language implementations, with minimal instrumentation of the original interpreter. While it does not give the performance improvements of hand-crafted native compilers, our system provides an appealing point on the language implementation spectrum.},
+ booktitle = {Proceedings of the 2003 workshop on Interpreters, virtual machines and emulators},
+ publisher = {{ACM}},
+ author = {Gregory T. Sullivan and Derek L. Bruening and Iris Baron and Timothy Garnett and Saman Amarasinghe},
+ year = {2003},
+ pages = {50--57},
+},
+
+ at inbook{bolz_back_2008,
+ title = {Back to the Future in One Week — Implementing a Smalltalk {VM} in {PyPy}},
+ url = {http://dx.doi.org/10.1007/978-3-540-89275-5_7},
+ abstract = {We report on our experiences with the Spy project, including implementation details and benchmark results. Spy is a re-implementation of the Squeak (i.e. Smalltalk-80) {VM} using the {PyPy} toolchain. The {PyPy} project allows code written in {RPython,} a subset of Python, to be translated
+to a multitude of different backends and architectures. During the translation, many aspects of the implementation can be
+independently tuned, such as the garbage collection algorithm or threading implementation. In this way, a whole host of interpreters
+can be derived from one abstract interpreter definition. Spy aims to bring these benefits to Squeak, allowing for greater portability and, eventually, improved performance. The current
+Spy codebase is able to run a small set of benchmarks that demonstrate performance superior to many similar Smalltalk {VMs,} but
+which still run slower than in Squeak itself. Spy was built from scratch over the course of a week during a joint {Squeak-PyPy} Sprint in Bern last autumn.
+},
+ booktitle = {{Self-Sustaining} Systems},
+ author = {Carl Friedrich Bolz and Adrian Kuhn and Adrian Lienhard and Nicholas Matsakis and Oscar Nierstrasz and Lukas Renggli and Armin Rigo and Toon Verwaest},
+ year = {2008},
+ pages = {123--139}
+},
+
+ at inproceedings{consel_general_1996,
+ address = {St. Petersburg Beach, Florida, United States},
+ title = {A general approach for run-time specialization and its application to C},
+ isbn = {0-89791-769-3},
+ url = {http://portal.acm.org/citation.cfm?id=237767},
+ doi = {10.1145/237721.237767},
+ abstract = {Note: {OCR} errors may be found in this Reference List extracted from the full text article. {ACM} has opted to expose the complete List rather than only correct and linked references.},
+ booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN-SIGACT} symposium on Principles of programming languages},
+ publisher = {{ACM}},
+ author = {Charles Consel and François Noël},
+ year = {1996},
+ pages = {145--156}
+},
- at InProceedings{AACM-DLS07,
- Author = {Ancona, D. and Ancona, M. and Cuni, A and Matsakis, N.},
- Title = {R{P}ython: a {S}tep {T}owards {R}econciling
- {D}ynamically and {S}tatically {T}yped {OO} {L}anguages},
- BookTitle = {O{OPSLA} 2007 {P}roceedings and {C}ompanion, {DLS}'07:
- {P}roceedings of the 2007 {S}ymposium on {D}ynamic
- {L}anguages},
- Pages = {53--64},
- Publisher = {ACM},
- year = 2007
+ at phdthesis{carl_friedrich_bolz_automatic_2008,
+ type = {Master Thesis},
+ title = {Automatic {JIT} Compiler Generation with Runtime Partial Evaluation
+},
+ school = {{Heinrich-Heine-Universität} Düsseldorf},
+ author = {Carl Friedrich Bolz},
+ year = {2008}
}
Modified: pypy/extradoc/talk/icooolps2009/paper.tex
==============================================================================
--- pypy/extradoc/talk/icooolps2009/paper.tex (original)
+++ pypy/extradoc/talk/icooolps2009/paper.tex Thu Apr 2 13:27:52 2009
@@ -159,7 +159,7 @@
new Python interpreter in Python but has now extended its goals to be an
environment where flexible implementation of dynamic languages can be written.
To implement a dynamic language with PyPy, an interpreter for that language has
-to be written in RPython \cite{AACM-DLS07}. RPython ("Restricted Python") is a subset of Python
+to be written in RPython \cite{ancona_rpython:step_2007}. RPython ("Restricted Python") is a subset of Python
chosen in such a way that type inference can be performed on it. The language
interpreter can then be translated with the help of PyPy into various target
environments, such as C/Posix, the CLI and the JVM. This is done by a component
@@ -749,7 +749,7 @@
specialisation is Tempo for C \cite{XXX}. However, it is essentially a normal
partial evaluator ``packaged as a library''; decisions about what can be
specialised and how are pre-determined. Another work in this direction is DyC
-\cite{grant_dyc_2000}, another runtime specializer for C. Both of these projects
+\cite{grant_dyc:expressive_2000}, another runtime specializer for C. Both of these projects
have a similar problem as DynamoRIO. Targeting the C language makes
higher-level specialisation difficult (e.g.\ \texttt{malloc} can not be
optimized).
More information about the Pypy-commit
mailing list