PyPy's approach to construct domain-specific language runtime

Tag: virtual machine, compiler, performance
PyPy’s Approach to Construct Domain-specific
Language Runtime

Tag: virtual machine, compiler, performance
Construct Domain-specific Language Runtime
using

Speed
7.4 times faster than CPython
http://speed.pypy.org
antocuni (PyCon Otto) PyPy Status Update April 07 2017 4 / 19

Why is Python slow?
Interpretation overhead
Boxed arithmetic and automatic overﬂow handling
Dynamic dispatch of operations
Dynamic lookup of methods and attributes
Everything can change on runtime
Extreme introspective and reﬂective capabilities
Francisco Fernandez Castano (@fcofdezc) PyPy November 8, 2014 8 / 51

Why is Python slow?
Boxed arithmetic and automatic overﬂow handling
i = 0
while i < 10000000:
i = i +1

Why is Python slow?
Dynamic dispatch of operations
# while i < 1000000
9 LOAD_FAST 0 (i)
12 LOAD_CONST 2 (10000000)
15 COMPARE_OP 0 (<)
18 POP_JUMP_IF_FALSE 34
# i = i + 1
21 LOAD_FAST 0 (i)
24 LOAD_CONST 3 (1)
27 BINARY_ADD
28 STORE_FAST 0 (i)
31 JUMP_ABSOLUTE 9

Why is Python slow?
Dynamic lookup of methods and attributes
class MyExample(object ):
pass
def foo(target , flag ):
if flag:
target.x = 42
obj = MyExample ()
foo(obj , True)
print obj.x #=> 42
print getattr(obj , "x") #=> 42

Why is Python slow?
def fn():
return 42
def hello ():
return ’Hi! PyConEs!’
def change_the_world ():
global fn
fn = hello
print fn() #=> 42
change_the_world ()
print fn() => ’Hi! PyConEs!’

Why is Python slow?
class Dog(object ):
def __init__(self ):
self.name = ’Jandemor ’
def talk(self ):
print "%s: guau!" % self.name
class Cat(object ):
def __init__(self ):
self.name = ’CatInstance ’
def talk(self ):
print "%s: miau!" % self.name

Why is Python slow?
my_pet = Dog()
my_pet.talk () #=> ’Jandemor: guau!’
my_pet.__class__ = Cat
my_pet.talk () #=> ’Jandemor: miau!’

Why is Python slow?
Extreme introspective and reﬂective capabilities
def fill_list(name ):
frame = sys._getframe (). f_back
lst = frame.f_locals[name]
lst.append (42)
def foo ():
things = []
fill_list(’things ’)
print things #=> 42

PyPy Translation Toolchain
• Capable of compiling (R)Python!
• Garbage collection!
• Tracing just-in-time compiler generator!
• Software transactional memory?

PyPy based interpreters
• Topaz (Ruby)!
• HippyVM (PHP)!
• Pyrolog (Prolog)!
• pycket (Racket)!
• Various other interpreters for (Scheme, Javascript,
io, Gameboy)

Compiler / Interpreter
Source: Compiler Construction, Prof. O. NierstraszSource: Compiler Construction, Prof. O. Nierstrasz

• intermediate representation (IR)
• front end maps legal code into IR
• back end maps IR onto target machine
• simplify retargeting
• allows multiple front ends
• multiple passes better code→
Traditional 2 pass compiler

• analyzes and changes IR
• goal is to reduce runtime
• must preserve values
Traditional 3 pass compiler

• constant propagation and folding
• code motion
• reduction of operator strength
• common sub-expression elimination
• redundant store elimination
• dead code elimination
Optimizer: middle end
Modern optimizers are usually built as a set of passes

• Preserve language semantics
• Reflection, Introspection, Eval
• External APIs
• Interpreter consists of short sequences of code
• Prevent global optimizations
• Typically implemented as a stack machine
• Dynamic, imprecise type information
• Variables can change type
• Duck Typing: method works with any object that provides
accessed interfaces
• Monkey Patching: add members to “class” after initialization
• Memory management and concurrency
• Function calls through packing of operands in fat object
Optimization Challenges

RPython
• Python subset!
• Statically typed!
• Garbage collected!
• Standard library almost entirely unavailable!
• Some missing builtins (print, open(), …)!
• rpython.rlib!
• exceptions are (sometimes) ignored!
• Not a really a language, rather a "state"

22
PyPy Interpreter
def f(x):
return x + 1
>>> dis.dis(f)
2 0 LOAD_FAST 0 (x)
3 LOAD_CONST 1 (1)
6 BINARY_ADD
7 RETURN_VALUE
• written in Rpython
• Stack-based bytecode interpreter (like JVM)
• bytecode compiler generates bytecode→
• bytecode evaluator interprets bytecode →
• object space handles operations on objects→

CFG (Call Flow Graph)
• Consists of Blocks and
Links
• Starting from entry_point
• “Single Static Information”
form
def f(n):
return 3 * n + 2
Block(v1): # input argument
v2 = mul(Constant(3), v1)
v3 = add(v2, Constant(2))

33
CFG: Static Single Information
33
def test(a):
if a > 0:
if a > 5:
return 10
return 4
if a < - 10:
return 3
return 10
• SSI: “PHIs” for all used variables
• Blocks as “functions without branches”

• High Level Language Implementation
• to implement new features: lazily computed objects
and functions, plug-able garbage-collection, runtime
replacement of live-objects, stackless concurrency
• JIT Generation
• Object space
• Stackless
• infinite Recursion
• Microthreads: Coroutines, Tasklets and Channels,
Greenlets
PyPy Advantages

PERCEPTION
http://abstrusegoose.com/secretarchives/under-the-hood - CC BY-NC 3.0 US

Assumptions
Pareto Principle (80-20 rule)
I the 20% of the program accounts for the 80% of the
runtime
I hot-spots
Fast Path principle
I optimize only what is necessary
I fall back for uncommon cases
Most of runtime spent in loops
Always the same code paths (likely)
antocuni (Intel@Bucharest) PyPy Intro April 4 2016 9 / 32

Tracing JIT phases
Interpretation

Tracing JIT phases
Interpretation
Tracing
hot loop detected

Tracing JIT phases
Interpretation
Tracing
hot loop detected
Compilation

Tracing JIT phases
Interpretation
Tracing
hot loop detected
Compilation
Running

Tracing JIT phases
Interpretation
Tracing
hot loop detected
Compilation
Running
cold guard failed

Tracing JIT phases
Interpretation
Tracing
hot loop detected
Compilation
Running
cold guard failed
entering compiled loop

Tracing JIT phases
Interpretation
Tracing
hot loop detected
Compilation
Running
cold guard failed
guard failure → hot

Tracing JIT phases
Interpretation
Tracing
hot loop detected
Compilation
Running
cold guard failed
guard failure → hot
hot guard failed

Trace trees (1)
tracetree.py
def foo():
a = 0
i = 0
N = 100
while i < N:
if i%2 == 0:
a += 1
else:
a *= 2;
i += 1
return a

Trace trees (2)
label(start, i0, a0)
v0 = int_lt(i0, 2000)
guard_true(v0)
v1 = int_mod(i0, 2)
v2 = int_eq(v1, 0)
guard_true(v1)
a1 = int_add(a0, 10)
i1 = int_add(i0, 1)
jump(start, i1, a1)

Trace trees (2)
v0 = int_lt(i0, 2000)
guard_true(v0)
v1 = int_mod(i0, 2)
v2 = int_eq(v1, 0)
guard_true(v1)
i1 = int_add(i0, 1)
jump(start, i1, a1)
BLACKHOLE
COLD FAIL

Trace trees (2)
v0 = int_lt(i0, 2000)
guard_true(v0)
v1 = int_mod(i0, 2)
v2 = int_eq(v1, 0)
guard_true(v1)
i1 = int_add(i0, 1)
jump(start, i1, a1)
BLACKHOLE
COLD FAIL
INTERPRETER

Trace trees (2)
v0 = int_lt(i0, 2000)
guard_true(v0)
v1 = int_mod(i0, 2)
v2 = int_eq(v1, 0)
guard_true(v1)
i1 = int_add(i0, 1)
jump(start, i1, a1)
a1 = int_mul(a0, 2)
i1 = int_add(i0, 1)
jump(start, i1, a1)
HOT FAIL

Part 3
The PyPy JIT

Terminology (1)
translation time: when you run "rpython
targetpypy.py" to get the pypy binary
runtime: everything which happens after you start
pypy
interpretation, tracing, compiling
assembler/machine code: the output of the JIT
compiler
execution time: when your Python program is being
executed
I by the interpreter
I by the machine code

Terminology (2)
interp-level: things written in RPython
[PyPy] interpreter: the RPython program which
executes the ﬁnal Python programs
bytecode: "the output of dis.dis". It is executed by the
PyPy interpreter.
app-level: things written in Python, and executed by
the PyPy Interpreter

Terminology (3)
(the following is not 100% accurate but it’s enough to
understand the general principle)
low level op or ResOperation
I low-level instructions like "add two integers", "read a ﬁeld
out of a struct", "call this function"
I (more or less) the same level of C ("portable assembler")
I knows about GC objects (e.g. you have getfield_gc
vs getfield_raw)
jitcodes: low-level representation of RPython
functions
I sequence of low level ops
I generated at translation time
I 1 RPython function --> 1 C function --> 1 jitcode

Terminology (4)
JIT traces or loops
I a very speciﬁc sequence of llops as actually executed by
your Python program
I generated at runtime (more speciﬁcally, during tracing)
JIT optimizer: takes JIT traces and emits JIT traces
JIT backend: takes JIT traces and emits machine
code

General architecture
def LOAD_GLOBAL(self):
...
def STORE_FAST(self):
...
def BINARY_ADD(self):
...
RPYTHON

...
...
...
RPYTHON
CODEWRITER

...
...
...
RPYTHON
CODEWRITER
...
p0 = getfield_gc(p0, 'func_globals')
p2 = getfield_gc(p1, 'strval')
call(dict_lookup, p0, p2)
....
...
p0 = getfield_gc(p0, 'locals_w')
setarrayitem_gc(p0, i0, p1)
....
...
promote_class(p0)
i0 = getfield_gc(p0, 'intval')
promote_class(p1)
i2 = int_add(i0, i1)
if (overflowed) goto ...
p2 = new_with_vtable('W_IntObject')
setfield_gc(p2, i2, 'intval')
....
JITCODE

...
...
...
RPYTHON
CODEWRITER
...
....
...
....
...
promote_class(p0)
promote_class(p1)
....
JITCODE
compile-time
runtime

...
...
...
RPYTHON
CODEWRITER
...
....
...
....
...
promote_class(p0)
promote_class(p1)
....
JITCODE
compile-time
runtime
META-TRACER

...
...
...
RPYTHON
CODEWRITER
...
....
...
....
...
promote_class(p0)
promote_class(p1)
....
JITCODE
compile-time
runtime
META-TRACEROPTIMIZER

...
...
...
RPYTHON
CODEWRITER
...
....
...
....
...
promote_class(p0)
promote_class(p1)
....
JITCODE
compile-time
runtime
META-TRACEROPTIMIZERBACKEND

...
...
...
RPYTHON
CODEWRITER
...
....
...
....
...
promote_class(p0)
promote_class(p1)
....
JITCODE
compile-time
runtime
META-TRACEROPTIMIZERBACKENDASSEMBLER

PyPy trace example
def fn():
c = a+b
...

PyPy trace example
def fn():
c = a+b
...
LOAD_GLOBAL A
LOAD_GLOBAL B
BINARY_ADD
STORE_FAST C

PyPy trace example
def fn():
c = a+b
...
LOAD_GLOBAL A
LOAD_GLOBAL B
BINARY_ADD
STORE_FAST C
...
...

PyPy trace example
def fn():
c = a+b
...
LOAD_GLOBAL A
LOAD_GLOBAL B
BINARY_ADD
STORE_FAST C
...
...
...
...

PyPy trace example
def fn():
c = a+b
...
LOAD_GLOBAL A
LOAD_GLOBAL B
BINARY_ADD
STORE_FAST C
...
...
...
...
...
guard_class(p0, W_IntObject)
i2 = int_add(00, i1)
guard_not_overflow()
...

PyPy trace example
def fn():
c = a+b
...
LOAD_GLOBAL A
LOAD_GLOBAL B
BINARY_ADD
STORE_FAST C
...
...
...
...
...
i2 = int_add(00, i1)
guard_not_overflow()
...
...
....

PyPy optimizer
intbounds
constant folding / pure operations
virtuals
string optimizations
heap (multiple get/setﬁeld, etc)
unroll

Intbound optimization (1)
intbound.py
def fn():
i = 0
while i < 5000:
i += 2
return i

Intbound optimization (2)
unoptimized
...
i17 = int_lt(i15, 5000)
guard_true(i17)
i19 = int_add_ovf(i15, 2)
guard_no_overflow()
...
optimized
...
i17 = int_lt(i15, 5000)
guard_true(i17)
i19 = int_add(i15, 2)
...
It works often
array bound checking
intbound info propagates all over the trace

Virtuals (1)
virtuals.py
def fn():
i = 0
while i < 5000:
i += 2
return i

Virtuals (2)
unoptimized
...
i1 = getfield_pure(p0, ’intval’)
i2 = int_add(i1, 2)
p3 = new(W_IntObject)
setfield_gc(p3, i2, ’intval’)
...
optimized
...
i2 = int_add(i1, 2)
...
The most important optimization (TM)
It works both inside the trace and across the loop
It works for tons of cases
I e.g. function frames

Constant folding (1)
constfold.py
def fn():
i = 0
while i < 5000:
i += 2
return i

Constant folding (2)
unoptimized
...
i2 = getfield_pure(<W_Int(2)>,
’intval’)
...
optimized
...
i3 = int_add(i1, 2)
...
It "ﬁnishes the job"
Works well together with other optimizations (e.g.
virtuals)
It also does "normal, boring, static" constant-folding

Out of line guards (1)
outoﬂineguards.py
N = 2
def fn():
i = 0
while i < 5000:
i += N
return i

Out of line guards (2)
unoptimized
...
quasiimmut_field(<Cell>, ’val’)
guard_not_invalidated()
p0 = getfield_gc(<Cell>, ’val’)
...
optimized
...
guard_not_invalidated()
...
i3 = int_add(i1, 2)
...
Python is too dynamic, but we don’t care :-)
No overhead in assembler code
Used a bit "everywhere"

Hello RPython
# hello_rpython.py
import os
!
def entry_point(argv):
os.write(2, “Hello, World!n”)
return 0
!
def target(driver, argv):
return entry_point, None

$ rpython hello_rpython.py
…
$ ./hello_python-c
Hello, RPython!

Goal
• BASIC interpreter capable of running Hamurabi!
• Bytecode based!
• Garbage Collection!
• Just-In-Time Compilation

Architecture
Parser
Compiler
Virtual Machine
AST
Bytecode
Source

10 PRINT TAB(32);"HAMURABI"
20 PRINT TAB(15);"CREATIVE COMPUTING MORRISTOWN, NEW JERSEY"
30 PRINT:PRINT:PRINT
80 PRINT "TRY YOUR HAND AT GOVERNING ANCIENT SUMERIA"
90 PRINT "FOR A TEN-YEAR TERM OF OFFICE.":PRINT
95 D1=0: P1=0
100 Z=0: P=95:S=2800: H=3000: E=H-S
110 Y=3: A=H/Y: I=5: Q=1
210 D=0
215 PRINT:PRINT:PRINT "HAMURABI: I BEG TO REPORT TO YOU,": Z=Z+1
217 PRINT "IN YEAR";Z;",";D;"PEOPLE STARVED,";I;"CAME TO THE CITY,"
218 P=P+I
227 IF Q>0 THEN 230
228 P=INT(P/2)
229 PRINT "A HORRIBLE PLAGUE STRUCK! HALF THE PEOPLE DIED."
230 PRINT "POPULATION IS NOW";P
232 PRINT "THE CITY NOW OWNS ";A;"ACRES."
235 PRINT "YOU HARVESTED";Y;"BUSHELS PER ACRE."
250 PRINT "THE RATS ATE";E;"BUSHELS."
260 PRINT "YOU NOW HAVE ";S;"BUSHELS IN STORE.": PRINT
270 REM *** MORE CODE THAT DID NOT FIT INTO THE SLIDE FOLLOWS

Parser
Parser
Abstract Syntax Tree (AST)
Source

Parser
Parser
AST
Source
Lexer
Tokens
Source
Parser
AST

RPLY
• Based on PLY, which is based on Lex and Yacc!
• Lexer generator!
• LALR parser generator

Lexer
from rply import LexerGenerator
!
lg = LexerGenerator()
!
lg.add(“NUMBER”, “[0-9]+”)
# …
lg.ignore(“ +”) # whitespace
!
lexer = lg.build().lex

lg.add('NUMBER', r'[0-9]*.[0-9]+')
lg.add('PRINT', r'PRINT')
lg.add('IF', r'IF')
lg.add('THEN', r'THEN')
lg.add('GOSUB', r'GOSUB')
lg.add('GOTO', r'GOTO')
lg.add('INPUT', r'INPUT')
lg.add('REM', r'REM')
lg.add('RETURN', r'RETURN')
lg.add('END', r'END')
lg.add('FOR', r'FOR')
lg.add('TO', r'TO')
lg.add('NEXT', r'NEXT')
lg.add('NAME', r'[A-Z][A-Z0-9$]*')
lg.add('(', r'(')
lg.add(')', r')')
lg.add(';', r';')
lg.add('STRING', r'"[^"]*"')
lg.add(':', r'r?n')
lg.add(':', r':')
lg.add('=', r'=')
lg.add('<>', r'<>')
lg.add('-', r'-')
lg.add('/', r'/')
lg.add('+', r'+')
lg.add('>=', r'>=')
lg.add('>', r'>')
lg.add('***', r'***.*')
lg.add('*', r'*')
lg.add('<=', r'<=')
lg.add('<', r'<')

>>> from basic.lexer import lex
>>> source = open("hello.bas").read()
>>> for token in lex(source):
... print token
Token("NUMBER", "10")
Token("PRINT", "PRINT")
Token("STRING",'"HELLO BASIC!"')
Token(":", "n")

Grammar
• A set of formal rules that deﬁnes the syntax!
• terminals = tokens!
• nonterminals = rules deﬁning a sequence of one or
more (non)terminals

program :
program : line
program : line program

statements : statement
statements : statement statements

statement : PRINT :
statement : PRINT expressions :
expressions : expression
expressions : expression ;
expressions : expression ; expressions

statement : NAME = expression :

statement : IF expression THEN number :

statement : GOTO NUMBER :
statement : GOSUB NUMBER :
statement : RETURN :

statement : FOR NAME = NUMBER TO NUMBER :
statement : NEXT NAME :

expression : NUMBER
expression : NAME
expression : STRING
expression : operation
expression : ( expression )
expression : NAME ( expression )

operation : expression + expression
operation : expression - expression
operation : expression * expression
operation : expression / expression
operation : expression <= expression
operation : expression < expression
operation : expression = expression
operation : expression <> expression
operation : expression > expression
operation : expression >= expression

from rply.token import BaseBox
!
class Program(BaseBox):
def __init__(self, lines): 
self.lines = lines
AST

class Line(BaseBox):
def __init__(self, lineno, statements):
self.lineno = lineno
self.statements = statements

class Statements(BaseBox):
def __init__(self, statements):
self.statements = statements

class Print(BaseBox):
def __init__(self, expressions, newline=True):
self.expressions = expressions
self.newline = newline

from rply import ParserGenerator
!
pg = ParserGenerator(["NUMBER", "PRINT", …])
Parser

@pg.production("program : ")
@pg.production("program : line")
@pg.production("program : line program")
def program(p):
if len(p) == 2:
return Program([p[0]] + p[1].get_lines())
return Program(p)

@pg.production("line : number statements")
def line(p):
return Line(p[0], p[1].get_statements())

@pg.production("op : expression + expression")
@pg.production("op : expression * expression")
def op(p):
if p[1].gettokentype() == "+":
return Add(p[0], p[2])
elif p[1].gettokentype() == "*":
return Mul(p[0], p[2])

pg = ParserGenerator([…], precedence=[
("left", ["+", "-"]),
("left", ["*", "/"])
])

Compiler/Virtual Machine
Compiler
Virtual Machine
AST
Bytecode

class VM(object):
def __init__(self, program):
self.program = program

class VM(object):
self.pc = 0

class VM(object):
self.pc = 0
self.frames = []

class VM(object):
self.pc = 0
self.frames = []
self.iterators = []

class VM(object):
self.pc = 0
self.frames = []
self.iterators = []
self.stack = []

class VM(object):
self.pc = 0
self.frames = []
self.iterators = {}
self.stack = []
self.variables = {}

class VM(object):
…
def execute(self):
while self.pc < len(self.program.instructions):
self.execute_bytecode(self.program.instructions[self.pc])

class VM(object):
…
def execute_bytecode(self, code):
raise NotImplementedError(code)

class VM(object):
...
def execute_bytecode(self):
if isinstance(code, TYPE):
self.execute_TYPE(code)
...
else:
raise NotImplementedError(code)

class Program(object):
def __init__(self):
self.instructions = []
Bytecode

class Instruction(object):
pass

class Number(Instruction):
def __init__(self, value):
self.value = value
!
class String(Instructions):
self.value = value

class Print(Instruction):
def __init__(self, expressions, newline):
self.expressions = expressions
self.newline = newline

class Call(Instruction):
def __init__(self, function_name):
self.function_name = function_name

class Let(Instruction):
def __init__(self, name):
self.name = name

class Lookup(Instruction):
self.name = name

class Add(Instruction):
pass
!
class Sub(Instruction):
pass
!
class Mul(Instruction):
pass
!
class Equal(Instruction):
pass
!
...

class GotoIfTrue(Instruction):
def __init__(self, target):
self.target = target
!
class Goto(Instruction):
def __init__(self, target, with_frame=False):
self.target = target
self.with_frame = with_frame
!
class Return(Instruction):
pass

class Input(object):
self.name = name

class For(Instruction):
def __init__(self, variable):
self.variable = variable
!
class Next(Instruction):
def __init__(self, variable):
self.variable = variable

class Program(object):
def __init__(self):
self.instructions = []
self.lineno2instruction = {}
!
def __enter__(self):
return self
!
def __exit__(self, exc_type, exc_value, tb):
if exc_type is None:
for i, instruction in enumerate(self.instructions):
instruction.finalize(self, i)

def finalize(self, program, index):
self.target = program.lineno2instruction[self.target]

class Program(BaseBox):
…
def compile(self):
with bytecode.Program() as program:
for line in self.lines:
line.compile(program)
return program

class Line(BaseBox):
...
def compile(self, program):
program.lineno2instruction[self.lineno] = len(program.instructions)
for statement in self.statements:
statement.compile(program)

class Print(Statement):
for expression in self.expressions:
expression.compile(program)
program.instructions.append(
bytecode.Print(
len(self.expressions),
self.newline
)
)

class Print(Statement):
...
for expression in self.expressions:
expression.compile(program)
bytecode.Print(
len(self.expressions),
self.newline
)
)

class Let(Statement):
...
self.value.compile(program)
bytecode.Let(self.name)
)

class Input(Statement):
...
bytecode.Input(self.variable)
)

class Goto(Statement):
...
bytecode.Goto(self.target)
)
!
class Gosub(Statement):
...
bytecode.Goto(
self.target,
with_frame=True
)
)
!
class Return(Statement):
...
bytecode.Return()
)

class For(Statement):
...
self.start.compile(program)
bytecode.Let(self.variable)
)
self.end.compile(program)
bytecode.For(self.variable)
)

class WrappedObject(object):
pass
!
class WrappedString(WrappedObject):
self.value = value
!
class WrappedFloat(WrappedObject):
self.value = value

class VM(object):
…
def execute_number(self, code):
self.stack.append(WrappedFloat(code.value))
self.pc += 1
!
def execute_string(self, code):
self.stack.append(WrappedString(code.value))
self.pc += 1

class VM(object):
…
def execute_call(self, code):
argument = self.stack.pop()
if code.function_name == "TAB":
self.stack.append(WrappedString(" " * int(argument)))
elif code.function_name == "RND":
self.stack.append(WrappedFloat(random.random()))
...
self.pc += 1

class VM(object):
…
def execute_let(self, code):
value = self.stack.pop()
self.variables[code.name] = value
self.pc += 1
!
def execute_lookup(self, code):
value = self.variables[code.name]
self.stack.append(value)
self.pc += 1

class VM(object):
…
def execute_add(self, code):
right = self.stack.pop()
left = self.stack.pop()
self.stack.append(WrappedFloat(left + right))
self.pc += 1

class VM(object):
…
def execute_goto_if_true(self, code):
condition = self.stack.pop()
if condition:
self.pc = code.target
else:
self.pc += 1

class VM(object):
…
def execute_goto(self, code):
if code.with_frame:
self.frames.append(self.pc + 1)
self.pc = code.target

class VM(object):
…
def execute_return(self, code):
self.pc = self.frames.pop()

class VM(object):
…
def execute_input(self, code):
value = WrappedFloat(float(raw_input() or “0.0”))
self.variables[code.name] = value
self.pc += 1

class VM(object):
…
def execute_for(code):
self.pc += 1
self.iterators[code.variable] = (
self.pc,
self.stack.pop()
)

class VM(object):
…
def execute_next(self, code):
loop_begin, end = self.iterators[code.variable]
current_value = self.variables[code.variable].value
next_value = current_value + 1.0
if next_value <= end:
self.variables[code.variable] =
WrappedFloat(next_value)
self.pc = loop_begin
else:
del self.iterators[code.variable]
self.pc += 1

def entry_point(argv):
try:
filename = argv[1]
except IndexError:
print(“You must supply a filename”)
return 1
content = read_file(filename)
tokens = lex(content)
ast = parse(tokens)
program = ast.compile()
vm = VM(program)
vm.execute()
return 0
Entry Point

JIT (in PyPy)
1. Identify “hot" loops!
2. Create trace inserting guards based on observed
values!
3. Optimize trace!
4. Compile trace!
5. Execute machine code instead of interpreter

from rpython.rlib.jit import JitDriver
!
jitdriver = JitDriver(
greens=[“pc”, “vm”, “program”, “frames”, “iterators”],
reds=[“stack”, “variables"]
)

class VM(object):
…
def execute(self):
while self.pc < len(self.program.instructions):
jitdriver.merge_point(
vm=self,
pc=self.pc,
…
)

Benchmark
10 N = 1
20 IF N <= 10000 THEN 40
30 END
40 GOSUB 100
50 IF R = 0 THEN 70
60 PRINT "PRIME"; N
70 N = N + 1: GOTO 20
100 REM *** ISPRIME N -> R
110 IF N <= 2 THEN 170
120 FOR I = 2 TO (N - 1)
130 A = N: B = I: GOSUB 200
140 IF R <> 0 THEN 160
150 R = 0: RETURN
160 NEXT I
170 R = 1: RETURN
200 REM *** MOD A -> B -> R
210 R = A - (B * INT(A / B))
220 RETURN

cbmbasic 58.22s
basic-c 5.06s
basic-c-jit 2.34s
Python implementation (CPython) 2.83s
Python implementation (PyPy) 0.11s
C implementation 0.03s

Project milestones
2008 Django support
2010 First JIT-compiler
2011 Compatibility with CPython 2.7
2014 Basic ARM support
CPython 3 support
Improve compatibility with C extensions
NumPyPy
Multi-threading support

PyPy STM
http://dabeaz.com/GIL/gilvis/
GIL locking

PyPy STM
10 loops, best of 3: 1.2 sec per loop10 loops, best of 3: 822 msec per loop
from threading import Thread
def count(n):
while n > 0:
n -= 1
def run():
t1 = Thread(target=count, args=(10000000,))
t1.start()
t2 = Thread(target=count, args=(10000000,))
t2.start()
t1.join(); t2.join()
def count(n):
while n > 0:
n -= 1
def run():
count(10000000)
count(10000000)
Inside the Python GIL - David Beazley

PyPy in the real world (1)
High frequency trading platform for sports bets
I low latency is a must
PyPy used in production since 2012
~100 PyPy processes running 24/7
up to 10x speedups
I after careful tuning and optimizing for PyPy

Real-time online advertising auctions
I tight latency requirement (<100ms)
I high throughput (hundreds of thousands of requests per
second)
30% speedup
We run PyPy basically everywhere
Julian Berman

IoT on the cloud
5-10x faster
We do not even run benchmarks on CPython
because we just know that PyPy is way faster
Tobias Oberstein

PyPy's approach to construct domain-specific language runtime

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (15)

Similar to PyPy's approach to construct domain-specific language runtime

Similar to PyPy's approach to construct domain-specific language runtime (20)

More from National Cheng Kung University

More from National Cheng Kung University (16)

Recently uploaded

Recently uploaded (20)

PyPy's approach to construct domain-specific language runtime