[pypy-svn] r64295 - pypy/extradoc/talk
arigo at codespeak.net
arigo at codespeak.net
Fri Apr 17 18:55:51 CEST 2009
Author: arigo
Date: Fri Apr 17 18:55:51 2009
New Revision: 64295
Added:
pypy/extradoc/talk/bibtex.bib
Log:
Add this file, mostly extracted from the directories icooolps2009*.
Added: pypy/extradoc/talk/bibtex.bib
==============================================================================
--- (empty file)
+++ pypy/extradoc/talk/bibtex.bib Fri Apr 17 18:55:51 2009
@@ -0,0 +1,116 @@
+
+ at Article{PyPyTracing,
+ author = {Carl Friedrich Bolz and Antonio Cuni and Armin Rigo and Maciej Fijalkowski},
+ title = {Tracing the Meta-Level: PyPy's Tracing JIT Compiler},
+ journal = {\emph{Submitted to} ICOOOLPS'09},
+ }
+
+ at Article{antocuni_2009,
+ author = {Antonio Cuni and Davide Ancona and Armin Rigo},
+ title = {Faster than {C}\#: Efficient Implementation of Dynamic Languages on {.NET}},
+ journal = {\emph{Submitted to} ICOOOLPS'09},
+ }
+
+ 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}
+},
+
+ at inproceedings{ancona_rpython:dls_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 techreport{armin_rigo_jit_2007,
+ title = {{JIT} Compiler Architecture},
+ url = {http://codespeak.net/pypy/dist/pypy/doc/index-report.html}, abstract = {{PyPyâ~@~Ys} translation tool-chain â~@~S from the interpreter written in {RPython} to generated {VMs} for low-level platforms â~@~S is now able to extend those {VMs} with an automatically generated dynamic compiler, derived from the interpreter. This is achieved by a pragmatic application of partial evaluation techniques guided by a few hints added to the source of the interpreter. Crucial for the effectiveness of dynamic compilation is the use of run-time information to improve compilation results: in our approach, a novel powerful primitive called â~@~\promotionâ~@~] that â~@~\promotesâ~@~] run-time values to compile-time is used to that effect. In this report, we describe it along with other novel techniques that allow the approach to scale to something as large as {PyPyâ~@~Ys} Python interpreter.},
+ number = {D08.2},
+ institution = {{PyPy}},
+ author = {Armin Rigo and Samuele Pedroni},
+ month = may,
+ year = {2007}
+},
+
+ at inproceedings{camillo_bruni_pygirl:_2009,
+ title = {{PyGirl:} Generating {Whole-System} {VMs} from {High-Level} Prototypes using {PyPy}},
+ booktitle = {Tools, accepted for publication},
+ author = {Camillo Bruni and Toon Verwaest},
+ year = {2009},
+},
+
+ at inproceedings{RiBo07_223,
+ author = {Armin Rigo and Carl Friedrich Bolz},
+ title = {{How to not write Virtual Machines for Dynamic Languages
+}},
+ booktitle = {Proceeding of Dyla 2007},
+ abstract = {Typical modern dynamic languages have a growing number of
+ implementations. We explore the reasons for this situation,
+ and the limitations it imposes on open source or academic
+ communities that lack the resources to fine-tune and
+ maintain them all. It is sometimes proposed that
+ implementing dynamic languages on top of a standardized
+ general-purpose ob ject-oriented virtual machine (like Java
+ or .NET) would help reduce this burden. We propose a
+ complementary alternative to writing custom virtual machine
+ (VMs) by hand, validated by the PyPy pro ject: flexibly
+ generating VMs from a high-level specification, inserting
+ features and low-level details automatically – including
+ good just-in-time compilers tuned to the dynamic language at
+ hand. We believe this to be ultimately a better investment
+ of efforts than the development of more and more advanced
+ general-purpose object oriented VMs. In this paper we
+ compare these two approaches in detail.},
+pages = {--},
+ year = {2007},
+}
+
+ at inproceedings{rigo_representation-based_2004,
+ address = {Verona, Italy},
+ title = {Representation-Based Just-in-Time Specialization and the Psyco Prototype for Python},
+ isbn = {1-58113-835-0},
+ url = {http://portal.acm.org/citation.cfm?id=1014010},
+ doi = {10.1145/1014007.1014010},
+ abstract = {A powerful application of specialization is to remove interpretative overhead: a language can be implemented with an interpreter, whose performance is then improved by specializing it for a given program source. This approach is only moderately successful with very high level languages, where the operation of each single step can be highly dependent on run-time data and context. In the present paper, the Psyco prototype for the Python language is presented. It introduces two novel techniques. The first is just-in-time specialization, or specialization by need, which introduces the "unlifting" ability for a value to be promoted from run-time to compile-time during specialization -- the inverse of the lift operator of partial evaluation. Its presence gives an unusual and powerful perspective on the specialization process. The second technique is representations, a theory of data-oriented specialization generalizing the traditional specialization domains (i.e. the compile-time/run-time dichotomy).},
+ booktitle = {Proceedings of the 2004 {ACM} {SIGPLAN} Symposium on Partial Evaluation and Semantics-Based Program Manipulation},
+ publisher = {{ACM}},
+ author = {Armin Rigo},
+ year = {2004},
+ pages = {15--26}
+},
+
+ at inbook{bolz_back_2008,
+ title = {Back to the Future in One Week â~@~T 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 techreport{PyPyJIT09,
+ title = {Automatic generation of {JIT} compilers for dynamic
+ languages in .{NET}},
+ institution = {{DISI}, University of Genova and Institut f\"ur Informatik, {Heinrich-Heine-Universit\"at D\"usseldorf}},
+ author = {Davide Ancona and Carl Friedrich Bolz and Antonio Cuni and Armin Rigo},
+ year = {2008},
+},
More information about the Pypy-commit
mailing list