An ARM Backend for PyPyls Tracing JIT - STUPS Group

More documents

Recommendations

Info

16 4 PYPY• The graphs are transformed into graphs using operations closer to those of the targetplatform.• Several transformations can be performed on the graphs such as optimizations orthe insertion of a garbage collector.• Finally the graphs are converted to source code for the selected platform and compiled.Being a subset of Python, RPython shares the characteristic that it is a garbage collectedlanguage. This means that programs are free of low level details about memory management.For this reason RPython programs are not bound to a certain memory managementmodel. During the translation process different implementations of the memory managementand garbage collection can be added to the generated program, without affectingthe semantics of the program itself. PyPy supports several own garbage collector implementationsas well as the Boehm-Demers-Weiser conservative garbage collector [BW88].Other aspects of RPython and of the programs implemented using it can be chosen attranslation time, such as the use of tagged pointers or boxes to represent integers or howclasses should be represented in memory. These details are added to the program duringthe translation process.Because RPython is translated from live objects loaded within the Python interpreter, thefull power of the Python language can be used as a preprocessor for RPython allowingto dynamically generate RPython code at load time which can then be analyzed, transformedand translated to a lower level target [RP06].
175 PyPy’s Approach to Tracing JITsOne of the features provided by PyPy is that it includes a JIT compiler generator. Thisgenerator can be applied to language implementations generating a JIT compiler for thelanguage at translation time. Although the procedure is similar to adding other low leveldetails such as garbage collection, the JIT generator requires a few hints which need tobe provided by the language implementor. In this section we are going to describe thedetails of PyPy’s JIT. This section as well as the examples used here are based on thepaper "Tracing the meta-level: PyPy’s tracing JIT compiler" [BCFR09].PyPy’s tracing JIT is not specific to the Python interpreter, instead PyPy provides a tracingJIT generator which can be applied to any language implementation itself which is basedon PyPy. Because there are two interpreters involved in the discussion of PyPy’s JIT itis helpful to distinguish some terminologies. Following the naming scheme proposed in[BCFR09] first there is the language interpreter which runs a given program. There is alsothe interpreter used to perform tracing, which runs the language interpreter. We will callthis the tracing interpreter. Programs running on the language interpreter are called userprograms and loops within them are named user loops while interpreter loops refer to toloops within the language interpreter.As a running example for a language interpreter we are going to use the simple bytecodeinterpreter shown in Figure 6 from [BCFR09]. It is a bytecode interpreter with 256registers managed in a list. The inputs the interpreter takes are the bytecode as a list ofcharacters and an integer as an accumulator. A user program for our bytecode interpreteris shown in Figure 7, it calculates the square of the accumulator.A traditional tracing JIT, which is applied to a user program, would detects hot loops init. In difference to this approach PyPy’s tracing JIT is applied to the language interpreterand not the user program. The main hot loop of a language interpreter is its bytecodedispatch loop. One iteration of the dispatch loop corresponds to the execution of onebytecode instruction. It is rather unlikely that this loop will take similar code paths insubsequent iterations rendering one of the core assumptions of tracing JITs invalid.To solve this problems PyPy traces several iterations of the bytecode dispatch loop. Theloop is unrolled so far that it corresponds to a user loop. As mentioned before a loop in auser program occurs when the program counter has repeatedly the same value which canonly happen through backward jumps. Usually the program counter consists of the currentlist of bytecodes and the pointer or index to the currently executed bytecode. Sincethe JIT is not aware of which variables contain the program counter it needs to get thisinformation via hints placed by the implementor of the language interpreter. The tracingJIT can detect a user loop by checking the values that make up the program counter, aloop is found if these variables have a value they have had at previous point of the execution.The program counter can only have a previous value again if it is explicitly set toan earlier value. This can only happen at a backward jump in the language interpreter.Because the tracing JIT can also not know which parts of the language interpreter correspondto backward jumps it needs an additional hint to mark these places. The examplebytecode interpreter with the hints applied is shown in Figure 8. In the example, thevariables passed in the greens list to JitDriver class are those that compose the programcounter and those variables passed in the red are the ones that are not used for the
Page 1: INSTITUT FÜR INFORMATIKSoftwaretec
Page 5: AbstractA large part of the computi
Page 9 and 10: 31 IntroductionARM cores are presen
Page 11 and 12: 52 ARMARM is at the same time the n
Page 13 and 14: 2.2 The ARM Architecture 7The curre
Page 15 and 16: 2.2 The ARM Architecture 9and from
Page 17 and 18: 113 Just-in-Time CompilationJust-in
Page 19 and 20: 3.2 Trace Based Just-In-Time Compil
Page 21: 154 PyPyThe PyPy project was starte
Page 25 and 26: 5.1 The Shape of a Trace 19program
Page 27 and 28: 5.2 Optimizations 21loop_start(a0,
Page 29 and 30: 236 A Backend for PyPy’s JITIn th
Page 31 and 32: 6.1 Low level Code Generation Inter
Page 33 and 34: 6.2 Register Allocation 27def gen_l
Page 35 and 36: 6.3 Setup to Execute a Compiled Loo
Page 37 and 38: 6.4 Compiling Trace Operations 31Ac
Page 39 and 40: 6.4 Compiling Trace Operations 33of
Page 41 and 42: 6.5 Guards and Leaving the Loop 35o
Page 43 and 44: 37ARM using a cross compiler, such
Page 45 and 46: 8.2 Benchmarks 398.2.1 Python Bench
Page 47 and 48: 8.2 Benchmarks 41Benchmark cpython
Page 49 and 50: 8.2 Benchmarks 43Ratio6x5x4x3x2x1x0
Page 51 and 52: 8.2 Benchmarks 458.2.2 Prolog Bench
Page 53 and 54: 8.2 Benchmarks 47SWInojit, boehmjit
Page 55 and 56: 499 Related WorkThere are many virt
Page 57 and 58: 5111 AnnexBenchmark cpython [ms] no
Page 59 and 60: REFERENCES 53References[AACM07] ANC
Page 61 and 62: REFERENCES 55annual ACM SIGPLAN con
Page 63 and 64: LIST OF FIGURES 57List of Figures1

An ARM Backend for PyPyls Tracing JIT - STUPS Group

Create successful ePaper yourself

Delete template?

Save as template?