@comment{{This file has been generated by bib2bib 1.98}}
@comment{{Command line: bib2bib -c 'keywords : "dynamicLang"' /home/davide/latex/bibinputs/allMine.bib}}
@comment{{This file has been generated by Pybliographer}}
@inproceedings{CAR-ICOOLPS09,
author = {Cuni, A. and Ancona, D. and Rigo, A.},
title = {Faster than {C}\#: efficient implementation of dynamic
languages on {.NET}},
booktitle = {{ICOOOLPS} '09: Proceedings of the 4th workshop on the
{I}mplementation, {C}ompilation, {O}ptimization of
{O}bject-{O}riented {L}anguages and {P}rogramming
{S}ystems},
pages = {26--33},
address = {New York, NY, USA},
publisher = {ACM},
abstract = {The Common Language Infrastructure (CLI) is a virtual
machine expressly designed for implementing statically
typed languages such as C\#, therefore programs written
in dynamically typed languages are typically much
slower than C\# when executed on .NET. Recent
developments show that Just In Time (JIT) compilers can
exploit runtime type information to generate quite
efficient code. Unfortunately, writing a JIT compiler
is far from being simple. In this paper we report our
positive experience with automatic generation of JIT
compilers as supported by the PyPy infrastructure, by
focusing on JIT compilation for .NET. Following this
approach, we have in fact added a second layer of JIT
compilation, by allowing dynamic generation of more
efficient .NET bytecode, which in turn can be compiled
to machine code by the .NET JIT compiler. The main and
novel contribution of this paper is to show that this
two-layers JIT technique is effective, since programs
written in dynamic languages can run on .NET as fast as
(and in some cases even faster than) the equivalent C\#
programs. The practicality of the approach is
demonstrated by showing some promising experiments done
with benchmarks written in a simple dynamic language. },
doi = {http://doi.acm.org/10.1145/1565824.1565828},
ftp = {ftp://ftp.disi.unige.it/pub/person/AnconaD/ICOOOLPS09.pdf},
isbn = {978-1-60558-541-3},
keywords = {objects,dynamicLang},
location = {Genova, Italy},
year = 2009
}
@techreport{ABCR1208,
author = {Ancona, D. and Bolz, C. and Cuni, A. and Rigo, A.},
title = {Automatic generation of {JIT} compilers for dynamic
languages in .{NET}},
institution = {Univ. of Dusseldorf and Univ. of Genova},
abstract = {Writing an optimizing static compiler for dynamic
languages is not an easy task, since quite complex
static analysis is required. On the other hand, recent
developments show that JIT compilers can exploit
runtime type information to generate quite efficient
code. Unfortunately, writing a JIT compiler is far from
being simple. In this paper we report our positive
experience with automatic generation of JIT compilers
as supported by the PyPy infrastructure, by focusing on
JIT compilation for .NET. The paper presents two main
and novel contributions: we show that partial
evaluation can be used in practice for generating a JIT
compiler, and we experiment with the potentiality
offered by the ability to add a further level of JIT
compilation on top of .NET. The practicality of the
approach is demonstrated by showing some promising
experiments done with benchmarks written in a simple
dynamic language.},
ftp = {ftp://ftp.disi.unige.it/person/AnconaD/ABCR1208.pdf},
keywords = {objects,dynamicLang},
month = dec,
year = 2008
}
@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},
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. We
describe a different approach that attempts to preserve
the flexibility of Python, while still allowing for
efficient execution. This is achieved by limiting the
use of the more dynamic features of Python to an
initial, bootstrapping phase. This phase is used to
construct a final RPython (Restricted Python) program
that is actually executed. RPython is a proper subset
of Python, is statically typed, and does not allow
dynamic modification of class or method definitions;
however, it can still take advantage of Python features
such as mixins and first-class methods and classes.
This paper presents an overview of RPython, including
its design and its translation to both CLI and JVM
bytecode. We show how the bootstrapping phase can be
used to implement advanced features, like extensible
classes and generative programming. We also discuss
what work remains before RPython is truly ready for
general use, and compare the performance of RPython
with that of other approaches.},
ftp = {ftp://ftp.disi.unige.it/pub/person/AnconaD/DLS08.pdf},
keywords = {objects,dynamicLang},
year = 2007
}
This file was generated by bibtex2html 1.98.