Author: David Schneider <david.schnei...@picle.org>
Branch: extradoc
Changeset: r4782:bdf35c43ec6c
Date: 2012-09-07 11:42 +0200
http://bitbucket.org/pypy/extradoc/changeset/bdf35c43ec6c/
Log: tweak bibliography
diff --git a/talk/vmil2012/paper.bib b/talk/vmil2012/paper.bib
--- a/talk/vmil2012/paper.bib
+++ b/talk/vmil2012/paper.bib
@@ -2,9 +2,8 @@
author = {Gal, Andread and Probst, Christian W. and Franz, Michael},
title = {{HotpathVM: An Effective JIT Compiler for
Resource-constrained Devices}},
location = {Ottawa, {Ontario}, {Canada}},
- series = {{VEE} '06},
+ series = {{VEE} 2006},
isbn = {1-59593-332-6},
- booktitle = {Proceedings of the 2nd International Conference on
Virtual Execution Environments},
publisher = {{ACM}},
year = {2006},
pages = {144-153}
@@ -12,13 +11,13 @@
@inproceedings{Gal:2009ux,
author = {Gal, Andreas and Franz, Michael and Eich, B and Shaver, M
and Anderson, David},
title = {{Trace-based Just-in-Time Type Specialization for Dynamic
Languages}},
- booktitle = {PLDI '09: Proceedings of the ACM SIGPLAN 2009 conference
on Programming language design and implementation},
+ booktitle = {PLDI 2009},
url = {http://portal.acm.org/citation.cfm?id=1542528},
}
@inproceedings{Bala:2000wv,
author = {Bala, Vasanth and Duesterwald, Evelyn and Banerjia, Sanjeev},
title = {{Dynamo: A Transparent Dynamic Optimization System}},
- booktitle = {PLDI '00: Proceedings of the ACM SIGPLAN 2000 conference
on Programming language design and implementation},
+ booktitle = {PLDI 2000},
}
@misc{Pall:2009,
author = {Pall, Mike},
diff --git a/talk/vmil2012/zotero.bib b/talk/vmil2012/zotero.bib
--- a/talk/vmil2012/zotero.bib
+++ b/talk/vmil2012/zotero.bib
@@ -19,7 +19,7 @@
url =
{http://portal.acm.org/citation.cfm?id=1735997.1736005&coll=&dl=GUIDE&type=series&idx=SERIES11259&part=series&WantType=Proceedings&title=VEE&CFID=82768812&CFTOKEN=13856884},
doi = {10.1145/1735997.1736005},
abstract = {Intense research on virtual machines has highlighted the
need for flexible software architectures that allow quick evaluation of new
design and implementation techniques. The interface between the compiler and
runtime system is a principal factor in the flexibility of both components and
is critical to enabling rapid pursuit of new optimizations and features.
Although many virtual machines have demonstrated modularity for many
components, significant dependencies often remain between the compiler and the
runtime system components such as the object model and memory management
system. This paper addresses this challenge with a carefully designed strict
compiler-runtime interface and the {XIR} language. Instead of the compiler
backend lowering object operations to machine operations using hard-wired
runtime-specific logic, {XIR} allows the runtime system to implement this
logic, simultaneously simplifying and separating the backend from
runtime-system details. In this pap
er we describe the design and implementation of this compiler-runtime
interface and the {XIR} language in the {C1X} dynamic compiler, a port of the
{HotSpotTM} Client compiler. Our results show a significant reduction in
backend complexity with {XIR} and an overall reduction in the compiler-runtime
interface complexity while still generating comparable quality code with only
minor impact on compilation time.},
- booktitle = {Proceedings of the 6th {ACM} {SIGPLAN/SIGOPS}
international conference on Virtual execution environments},
+ booktitle = {VEE 2010},
publisher = {{ACM}},
author = {Titzer, Ben L. and Würthinger, Thomas and Simon, Doug
and Cintra, Marcelo},
year = {2010},
@@ -77,7 +77,7 @@
url = {http://portal.acm.org/citation.cfm?id=1806598},
doi = {10.1145/1806596.1806598},
abstract = {The {JavaScript} programming language is widely used for
web programming and, increasingly, for general purpose computing. As such,
improving the correctness, security and performance of {JavaScript}
applications has been the driving force for research in type systems, static
analysis and compiler techniques for this language. Many of these techniques
aim to reign in some of the most dynamic features of the language, yet little
seems to be known about how programmers actually utilize the language or these
features. In this paper we perform an empirical study of the dynamic behavior
of a corpus of widely-used {JavaScript} programs, and analyze how and why the
dynamic features are used. We report on the degree of dynamism that is
exhibited by these {JavaScript} programs and compare that with assumptions
commonly made in the literature and accepted industry benchmark suites.},
- booktitle = {Proceedings of the 2010 {ACM} {SIGPLAN} conference on
Programming language design and implementation},
+ booktitle = {PLDI 2010},
publisher = {{ACM}},
author = {Richards, Gregor and Lebresne, Sylvain and Burg, Brian and
Vitek, Jan},
year = {2010},
@@ -86,18 +86,15 @@
},
@inproceedings{kotzmann_escape_2005,
- address = {New York, {NY}, {USA}},
series = {{VEE} '05},
title = {Escape analysis in the context of dynamic compilation and
deoptimization},
isbn = {1-59593-047-7},
location = {Chicago, {IL}, {USA}},
doi = {10.1145/1064979.1064996},
abstract = {In object-oriented programming languages, an object is said
to escape the method or thread in which it was created if it can also be
accessed by other methods or threads. Knowing which objects do not escape
allows a compiler to perform aggressive {optimizations.This} paper presents a
new intraprocedural and interprocedural algorithm for escape analysis in the
context of dynamic compilation where the compiler has to cope with dynamic
class loading and deoptimization. It was implemented for Sun Microsystems' Java
{HotSpot™} client compiler and operates on an intermediate representation
in {SSA} form. We introduce equi-escape sets for the efficient propagation of
escape information between related objects. The analysis is used for scalar
replacement of fields and synchronization removal, as well as for stack
allocation of objects and fixed-sized arrays. The results of the
interprocedural analysis support the compiler in inlining decisions and allow
actual parameters
to be allocated on the caller {stack.Under} certain circumstances, the Java
{HotSpot™} {VM} is forced to stop executing a method's machine code and
transfer control to the interpreter. This is called deoptimization. Since the
interpreter does not know about the scalar replacement and synchronization
removal performed by the compiler, the deoptimization framework was extended to
reallocate and relock objects on demand.},
- booktitle = {Proceedings of the 1st {ACM/USENIX} international
conference on Virtual execution environments},
publisher = {{ACM}},
author = {Kotzmann, Thomas and Mössenböck, Hanspeter},
year = {2005},
- note = {{ACM} {ID:} 1064996},
keywords = {algorithms, allocation/deallocation strategies,
deoptimization},
pages = {111–120}
},
@@ -113,14 +110,12 @@
},
@inproceedings{bolz_runtime_2011,
- address = {New York, {NY}, {USA}},
series = {{ICOOOLPS} '11},
title = {Runtime feedback in a meta-tracing {JIT} for efficient dynamic
languages},
isbn = {978-1-4503-0894-6},
url = {http://doi.acm.org/10.1145/2069172.2069181},
doi = {10.1145/2069172.2069181},
abstract = {Meta-tracing {JIT} compilers can be applied to a variety of
different languages without explicitly encoding language semantics into the
compiler. So far, they lacked a way to give the language implementor control
over runtime feedback. This restricted their performance. In this paper we
describe the mechanisms in {PyPy’s} meta-tracing {JIT} that can be used
to control runtime feedback in language-specific ways. These mechanisms are
flexible enough to express classical {VM} techniques such as maps and runtime
type feedback.},
- booktitle = {Proceedings of the 6th Workshop on Implementation,
Compilation, Optimization of Object-Oriented Languages, Programs and Systems},
publisher = {{ACM}},
author = {Bolz, Carl Friedrich and Cuni, Antonio and Fijałkowski,
Maciej and Leuschel, Michael and Pedroni, Samuele and Rigo, Armin},
year = {2011},
@@ -129,7 +124,6 @@
},
@inproceedings{callau_how_2011,
- address = {New York, {NY}, {USA}},
series = {{MSR} '11},
title = {How developers use the dynamic features of programming
languages: the case of {Smalltalk}},
isbn = {978-1-4503-0574-7},
@@ -162,14 +156,12 @@
},
@inproceedings{holzle_debugging_1992,
- address = {New York, {NY}, {USA}},
series = {{PLDI} '92},
title = {Debugging optimized code with dynamic deoptimization},
isbn = {0-89791-475-9},
url = {http://doi.acm.org/10.1145/143095.143114},
doi = {10.1145/143095.143114},
abstract = {{SELF's} debugging system provides complete source-level
debugging (expected behavior) with globally optimized code. It shields the
debugger from optimizations performed by the compiler by dynamically
deoptimizing code on demand. Deoptimization only affects the procedure
activations that are actively being debugged; all other code runs at full
speed. Deoptimization requires the compiler to supply debugging information at
discrete interrupt points; the compiler can still perform extensive
optimizations between interrupt points without affecting debuggability. At the
same time, the inability to interrupt between interrupt points is invisible to
the user. Our debugging system also handles programming changes during
debugging. Again, the system provides expected behavior: it is possible to
change a running program and immediately observe the effects of the change.
Dynamic deoptimization transforms old compiled code (which may contain inlined
copies of the old version of the
changed procedure) into new versions reflecting the current source-level
state. To the best of our knowledge, {SELF} is the first practical system
providing full expected behavior with globally optimized code.},
- booktitle = {Proceedings of the {ACM} {SIGPLAN} 1992 conference on
Programming language design and implementation},
publisher = {{ACM}},
author = {Hölzle, Urs and Chambers, Craig and Ungar, David},
year = {1992},
@@ -185,7 +177,6 @@
doi = {10.1109/CGO.2007.34},
abstract = {The {JavaTM} programming language does not allow the
programmer to influence memory management. An object is usually allocated on
the heap and deallocated by the garbage collector when it is not referenced any
longer. Under certain conditions, the virtual machine can allocate objects on
the stack or eliminate their allocation via scalar replacement. However, even
if the dynamic compiler guarantees that the conditions are fulfilled, the
optimizations require support by the run-time environment. We implemented a new
escape analysis algorithm for Sun Microsystems' Java {HotSpotTM} {VM.} The
results are used to replace objects with scalar variables, to allocate objects
on the stack, and to remove synchronization. This paper deals with the
representation of optimized objects in the debugging information and with
reallocation and garbage collection support for a safe execution of optimized
methods. Assignments to fields of parameters that can refer to both stack and
heap obje
cts are associated with an extended write barrier which skips card marking for
stack objects. The traversal of objects during garbage collection uses a
wrapper that abstracts from stack objects and presents their pointer fields as
root pointers to the garbage collector. When a previously compiled and
currently executing method must be continued in the interpreter because dynamic
class loading invalidates the machine code, execution is suspended and compiler
optimizations are undone. Scalar-replaced objects are reallocated on the heap
lazily when control returns to the invalidated method, whereas stack-allocated
objects must be reallocated immediately before program execution resumes. After
reallocation, objects for which synchronization was removed are relocked.},
urldate = {2012-09-06},
- booktitle = {Proceedings of the International Symposium on Code
Generation and Optimization},
publisher = {{IEEE} Computer Society},
author = {Kotzmann, Thomas and Mossenbock, Hanspeter},
year = {2007},
@@ -227,7 +218,6 @@
number = {4},
journal = {{ACM} Transactions on Programming Languages and Systems},
author = {Cytron, Ron and Ferrante, Jeanne and Rosen, Barry K. and
Wegman, Mark N. and Zadeck, F. Kenneth},
- month = oct,
year = {1991},
pages = {451–490}
},
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
http://mail.python.org/mailman/listinfo/pypy-commit
