An ARM Backend for PyPyls Tracing JIT - STUPS Group

More documents

Recommendations

Info

22 5 PYPY’S APPROACH TO TRACING JITSloop_start(a0, regs0)# MOV_R_A 0a1 = list_getitem(regs0, Const(0))# DECR_Aa2 = int_sub(a1, Const(1))# MOV_A_R 0list_setitem(regs0, Const(0), a2)# MOV_R_A 2a3 = list_getitem(regs0, Const(2))# ADD_R_TO_A 1i0 = list_getitem(regs0, Const(1))a4 = int_add(a3, i0)# MOV_A_R 2list_setitem(regs0, Const(2), a4)# MOV_R_A 0a5 = list_getitem(regs0, Const(0))# JUMP_IF_A 4i1 = int_is_true(a5)guard_true(i1)jump(a5, regs0)Figure 10: Trace when executing the Square function of Figure 7, with the correspondingopcodes as comments. The constant-folding of operations on green variables is enabled.
236 A Backend for PyPy’s JITIn this section we are going to explain how a backend for PyPy’s tracing JIT compiler isstructured, especially taking a look at how a backend is build to generate code suited forARM processors. Many of the ideas presented here were also used before in the x86 andx86_64 backends of PyPy’s JIT.The tasks necessary to compile and execute such a loop are manifold. There are several,rather independent components that need to in place before we can generate and executecode for a loop.First we need a way to generate executable machine code. We want to have a well structuredway to interface with it to avoid duplicating the logic of encoding the instructions,which is described in Subsection 6.1. Additionally we need a way to manage the registers.This tool should take care of associating registers to variables, keeping track of thebindings and taking care of freeing the registers. This interface is described in Subsection6.2. With these tools in place we can start creating the execution context for the loop.We want to create a procedure that acts as a container for the compiled loop that alsoprovides a context to hold the state while execution the loop, how the frame layout usedin the backend to hold the state is organized is described in Subsection 6.3.1 and howthe procedure that is used to encapsulate the trace works is described in Subsection 6.3.2.With all these components in place we can proceed to compile the operations containedin the trace, which is described in Subsection 6.4. How the loop is left and how we passinformation to the frontend so it can restore the execution state before resuming interpretationis described in Subsection 6.5. Finally how bridges are handled is described inSubsection 6.6.6.1 Low level Code Generation InterfaceBefore we can generate code from the traces passed from the frontend into the platformspecific backends we need a way to encode the machine instructions. In classical compilersthis is done by the assembler which provides a higher level interface to the instructionssupported by the processor, transforming them to their binary representation whichis then executable by the processor.Because the JIT compiler operates at runtime we need to provide an assembler that isavailable at runtime. To achieve this and to avoid having to encode repeatedly all instructionsas numbers by hand as well as to have a clean interface to the machine language wegenerate an assembler interface which provides functions named after the assembler instructions.Such a function encodes the arguments passed to it according to the platformdocumentation an stores the corresponding instruction to memory. In the ARM backendthis interface is provided by a class named CodeBuilder, so we are going to further referto this interface for simplicity as codebuilder.The assembler functions are exposed in the codebuilder using PyPy’s metaprogrammingfeatures by generating a function for each required instruction from anencoded representation of the specification at load time.As mentioned earlier the current ARM backend targets the ARM state/instruction set
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 and 22: 154 PyPyThe PyPy project was starte
Page 23 and 24: 175 PyPy’s Approach to Tracing JI
Page 25 and 26: 5.1 The Shape of a Trace 19program
Page 27: 5.2 Optimizations 21loop_start(a0,
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?