An efficient implementation of SELF a dynamically-typed object-oriented language based on prototypes
OOPSLA '89 Conference proceedings on Object-oriented programming systems, languages and applications
Making pure object-oriented languages practical
OOPSLA '91 Conference proceedings on Object-oriented programming systems, languages, and applications
Debugging optimized code with dynamic deoptimization
PLDI '92 Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation
A third-generation SELF implementation: reconciling responsiveness with performance
OOPSLA '94 Proceedings of the ninth annual conference on Object-oriented programming systems, language, and applications
Efficient support for complex numbers in Java
JAVA '99 Proceedings of the ACM 1999 conference on Java Grande
Efficient and precise modeling of exceptions for the analysis of Java programs
Proceedings of the 1999 ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering
LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation
Proceedings of the international symposium on Code generation and optimization: feedback-directed and runtime optimization
Experiences with Multi-threading and Dynamic Class Loading in a Java Just-In-Time Compiler
Proceedings of the International Symposium on Code Generation and Optimization
A principled approach to nondeferred reference-counting garbage collection
Proceedings of the fourth ACM SIGPLAN/SIGOPS international conference on Virtual execution environments
Trace-based just-in-time type specialization for dynamic languages
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
Tracing the meta-level: PyPy's tracing JIT compiler
Proceedings of the 4th workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages and Programming Systems
Evaluation of a just-in-time compiler retrofitted for PHP
Proceedings of the 6th ACM SIGPLAN/SIGOPS international conference on Virtual execution environments
Evaluating the dynamic behaviour of Python applications
ACSC '09 Proceedings of the Thirty-Second Australasian Conference on Computer Science - Volume 91
SPUR: a trace-based JIT compiler for CIL
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Allocation removal by partial evaluation in a tracing JIT
Proceedings of the 20th ACM SIGPLAN workshop on Partial evaluation and program manipulation
The impact of optional type information on jit compilation of dynamically typed languages
Proceedings of the 7th symposium on Dynamic languages
Reducing trace selection footprint for large-scale Java applications without performance loss
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Runtime feedback in a meta-tracing JIT for efficient dynamic languages
Proceedings of the 6th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems
Trace-based compilation for the Java HotSpot virtual machine
Proceedings of the 9th International Conference on Principles and Practice of Programming in Java
VEE '12 Proceedings of the 8th ACM SIGPLAN/SIGOPS conference on Virtual Execution Environments
Proceedings of the 2013 ACM international symposium on New ideas, new paradigms, and reflections on programming & software
Proceedings of the 19th international conference on Architectural support for programming languages and operating systems
Characteristics of dynamic JVM languages
Proceedings of the 7th ACM workshop on Virtual machines and intermediate languages
Optimizing R VM: Allocation Removal and Path Length Reduction via Interpreter-level Specialization
Proceedings of Annual IEEE/ACM International Symposium on Code Generation and Optimization
MuscalietJS: rethinking layered dynamic web runtimes
Proceedings of the 10th ACM SIGPLAN/SIGOPS international conference on Virtual execution environments
Hi-index | 0.00 |
Whenever the need to compile a new dynamically typed language arises, an appealing option is to repurpose an existing statically typed language Just-In-Time (JIT) compiler (repurposed JIT compiler). Existing repurposed JIT compilers (RJIT compilers), however, have not yet delivered the hoped-for performance boosts. The performance of JVM languages, for instance, often lags behind standard interpreter implementations. Even more customized solutions that extend the internals of a JIT compiler for the target language compete poorly with those designed specifically for dynamically typed languages. Our own Fiorano JIT compiler is an example of this problem. As a state-of-the-art, RJIT compiler for Python, the Fiorano JIT compiler outperforms two other RJIT compilers (Unladen Swallow and Jython), but still shows a noticeable performance gap compared to PyPy, today's best performing Python JIT compiler. In this paper, we discuss techniques that have proved effective in the Fiorano JIT compiler as well as limitations of our current implementation. More importantly, this work offers the first in-depth look at benefits and limitations of the repurposed JIT compiler approach. We believe the most common pitfall of existing RJIT compilers is not focusing sufficiently on specialization, an abundant optimization opportunity unique to dynamically typed languages. Unfortunately, the lack of specialization cannot be overcome by applying traditional optimizations.