[pypy-commit] extradoc extradoc: tweak bibliography
bivab
noreply at buildbot.pypy.org
Fri Sep 7 11:42:47 CEST 2012
Author: David Schneider <david.schneider at 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 paper 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 objects 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}
},
More information about the pypy-commit
mailing list