Representation-based just-in-time specialization and the psyco prototype for python

Rigo, Armin

doi:10.1145/1014007.1014010

Cited by 56 publications

(42 citation statements)

References 17 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Recent research has shown the advantages of type specialization in JIT compilation [19,10]. However, little research exists on the specialization of interpreters for scripting languages.…”

Section: Motivationmentioning

confidence: 99%

“…They used direct calling dispatch techniques in their interpreter to gradually develop a trace JIT of a hot region of code. Rigo's psyco [19] is a run time specialization technique for the Python programming language. It performs run time specialization by need using a mixed execution/specialization phase of execution to specialize JIT code fragments.…”

Section: Related Workmentioning

confidence: 99%

“…This typically adds a significant overhead to executing programs in dynamically typed languages. A goal of much research is to reduce or eliminate dynamic type checks in compilers or virtual machines for dynamically typed languages [3,10,19,17]. The Lua VM supports nine variable types: NIL, BOOLEAN, LIGHTUSERDATA, NUMBER, STRING, TABLE, FUNCTION, THREAD, USERDATA.…”

Section: Introductionmentioning

confidence: 99%

“…Performing these type checks forms a significant portion of program execution. These costs seem unnecessary especially when we realize the same variable types are inevitably rechecked as loop iterations repeat the execution of the same block of code.Recent research has shown the advantages of type specialization in JIT compilation [19,10]. However, little research exists on the specialization of interpreters for scripting languages.…”

mentioning

confidence: 99%

See 3 more Smart Citations

Dynamic interpretation for dynamic scripting languages

Williams

McCandless

Gregg

2010

Proceedings of the 8th Annual IEEE/ACM International Symposium on Code Generation and Optimization

View full text Add to dashboard Cite

Dynamic scripting languages offer programmers increased flexibility by allowing properties of programs to be defined at run-time. Typically, program execution begins with an interpreter where type checks are implemented using conditional statements. Recent JIT compilers have begun removing run-time checks by specializing native code to program properties discovered at JIT time.This paper presents a novel intermediate representation for scripting languages that explicitly encodes types of variables. The dynamic representation is a flow graph, where each node is a specialized virtual instruction and each edge directs program flow based on control and type changes in the program. The interpreter thus performs specialized execution of whole programs. We present techniques for the efficient interpretation of our representation showing speedups of greater than 2x over static interpretation, with an average speedup of approximately 1.3x. MotivationScripting language virtual machines (VMs) typically compile high-level source code into an array of low-level opcodes (bytecodes). They then use a standard interpretation loop to execute the array of opcodes. Run-time type checks are implemented with either conditional statements or switch statements. Performing these type checks forms a significant portion of program execution. These costs seem unnecessary especially when we realize the same variable types are inevitably rechecked as loop iterations repeat the execution of the same block of code.Recent research has shown the advantages of type specialization in JIT compilation [19,10]. However, little research exists on the specialization of interpreters for scripting languages. We propose a scripting language representation and interpretation technique that performs specialized execution of dynamic code. We present a dynamic intermediate representation (DIR) which explicitly encodes the types of variables at each point of execution. The DIR is a flow graph, where each node is a specialized virtual instruction and each edge directs program flow based on control and type changes in the program. The proposed DIR therefore has a specialized path in the graph for every sequence of control and type changes found during execution.In this paper we present the initial development of our prototype implementation in the Lua Virtual Machine [12,13]. We present the design of our dynamic representation as well as the techniques used for its efficient interpretation. We illustrate our representation with a motivating example and present our plans for future interpreter optimizations. We compare the interpretation of our representation to the standard Lua implementation and show early speedups reaching a max of 2.13x and an average of 1.3x. We present reductions in the total number of instructions executed including reductions in conditional branches (used in interpreter type checking) as well as decreases in data and instruction cache accesses.

show abstract

“…Recent research has shown the advantages of type specialization in JIT compilation [19,10]. However, little research exists on the specialization of interpreters for scripting languages.…”

Section: Motivationmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

mentioning

confidence: 99%

See 2 more Smart Citations

Dynamic interpretation for dynamic scripting languages

Williams

McCandless

Gregg

2010

Proceedings of the 8th Annual IEEE/ACM International Symposium on Code Generation and Optimization

View full text Add to dashboard Cite

show abstract

“…In order to show the difference and impact of a JIT and dynamic optimization for the interpreted PyGirl we use Psyco [9], a just-in-time specializer for Python. Since the current version of Psyco (1.6-1) only emits machine code for 32 bit intel-based systems, we benchmark our code using Psyco on a similar Ubuntu installation with the appropriate 32 bit processor.…”

Section: Benchmark Detailsmentioning

confidence: 99%

PyGirl: Generating Whole-System VMs from High-Level Prototypes Using PyPy

Bruni

Verwaest

2009

Objects, Components, Models and Patterns

View full text Add to dashboard Cite

Abstract. Virtual machines (VMs) emulating hardware devices are generally implemented in low-level languages for performance reasons. This results in unmaintainable systems that are difficult to understand. In this paper we report on our experience using the PyPy toolchain to improve the portability and reduce the complexity of whole-system VM implementations. As a case study we implement a VM prototype for a Nintendo Game Boy, called PyGirl, in which the high-level model is separated from low-level VM implementation issues. We shed light on the process of refactoring from a low-level VM implementation in Java to a high-level model in RPython. We show that our whole-system VM written with PyPy is significantly less complex than standard implementations, without substantial loss in performance.

show abstract

Python meets JIT compilers: A simple implementation and a comparative evaluation

Zhang,

Xu,

2023

Softw Pract Exp

View full text Add to dashboard Cite

Developing a just‐in‐time (JIT) compiler can be a daunting task, especially for a language as flexible as Python. While PyPy, powered with JIT compilation, can often outperform the official pure interpreter, CPython, by a noteworthy margin, its popularity remains far from comparable to that of CPython due to some issues. Given that an easier‐to‐deploy and better‐compatible JIT compiler would benefit more Python users, we have developed comPyler, a simple JIT compiler functioning as a CPython extension and intended to convert frequently interpreted CPython bytecode into equivalent machine code. Designed with good compatibility in mind, it does not alter CPython's internal data structures or external interfaces. Based on LLVM's mature infrastructure, it can be readily ported to almost all platforms. Compared with CPython, it achieved the highest speedup of 2.205, with an average of 1.093. Despite its relatively limited effect, comPyler incurs low development costs. As a baseline compiler, it also sheds light on the improvement attainable by optimizing solely the overhead of bytecode interpretation. Furthermore, as there is still a dearth of empirical research covering the multitude of JIT compilers available for Python, we have conducted a performance study that examines Jython, IronPython, PyPy, GraalPy, Pyston, Pyjion, and our comPyler. Our research takes into account not only the benchmark speed for various time windows but also the boot latency and memory footprint. Through this comprehensive study, our objective is to assist developers in gaining a better understanding of the effects of distinct JIT compilation techniques and to aid users in making informed decisions when choosing among different Python implementations.

show abstract

Representation-based just-in-time specialization and the psyco prototype for python

Cited by 56 publications

References 17 publications

Dynamic interpretation for dynamic scripting languages

Dynamic interpretation for dynamic scripting languages

PyGirl: Generating Whole-System VMs from High-Level Prototypes Using PyPy

Python meets JIT compilers: A simple implementation and a comparative evaluation

Contact Info

Product

Resources

About