PyPy Status Blog

some · better

axis
all
any
ndarray.flat
ndarray.flatten
ndarray.ravel
ndarray.take
out
x
yth
power:
    res = 1
    if y goto power_rec else goto power_done

power_rec:
    res = res * x
    y = y - 1
    if y goto power_rec else goto power_done

power_done:
    print_and_stop(res)

block(power, op1(res, same, const(1),
             if(y, power_rec, power_done))).
block(power_rec, op2(res, mul, var(res), var(x),
                 op2(y, sub, var(y), const(1),
                 if(y, power_rec, power_done)))).
block(power_done, print_and_stop(var(res))).

block
op1
op2
jump
if
print_and_stop
op1
op1(res_variable,
operation_name, argument, next_statement)
var(name)
const(value)
lookup(X, [], _) :- throw(key_not_found(X)).
lookup(Key, [Key/Value | _], Value) :- !.
lookup(Key, [_ | Rest], Value) :- lookup(Key, Rest, Value).

write_env([], X, V, [X/V]).
write_env([Key/_ | Rest], Key, Value, [Key/Value | Rest]) :- !.
write_env([Pair | Rest], Key, Value, [Pair | NewRest]) :- write_env(Rest, Key, Value, NewRest).

remove_env([], _, []).
remove_env([Key/_ | Rest], Key, Rest) :- !.
remove_env([Pair | Rest], Key, [Pair | NewRest]) :- remove_env(Rest, Key, NewRest).

resolve(const(X), _, X).
resolve(var(X), Env, Y) :- lookup(X, Env, Y).

lookup
write_env
remove_env
resolve
lookup
resolve
do_op
do_op(same, X, X).
do_op(mul, X, Y, Z) :- Z is X * Y.
do_op(add, X, Y, Z) :- Z is X + Y.
do_op(sub, X, Y, Z) :- Z is X - Y.
do_op(eq, X, Y, Z) :- X == Y -> Z = 1; Z = 0.
do_op(ge, X, Y, Z) :- X >= Y -> Z = 1; Z = 0.
do_op(readlist, L, I, X) :- nth0(I, L, X).
do_op(Op, _, _, _) :- throw(missing_op(Op)).

interp
interp(op1(ResultVar, Op, Arg, Rest), Env) :-
    resolve(Arg, Env, RArg),
    do_op(Op, RArg, Res),
    write_env(Env, ResultVar, Res, NEnv),
    interp(Rest, NEnv).

interp(op2(ResultVar, Op, Arg1, Arg2, Rest), Env) :-
    resolve(Arg1, Env, RArg1),
    resolve(Arg2, Env, RArg2),
    do_op(Op, RArg1, RArg2, Res),
    write_env(Env, ResultVar, Res, NEnv),
    interp(Rest, NEnv).

interp
print_and_stop
interp(jump(L), Env) :-
    block(L, Block),
    interp(Block, Env).

interp(print_and_stop(Arg), Env) :-
    resolve(Arg, Env, Val),
    print(Val), nl.

print_and_stop
interp(if(V, L1, L2), Env) :-
    lookup(V, Env, Val),
    (Val == 0 ->
        block(L2, Block)
    ;
        block(L1, Block)
    ),
    interp(Block, Env).

$ swipl -s cfglang.pl
?- block(power, Block), interp(Block, [x/10, y/10]).
10000000000

plookup(Key, [], var(Key)).
plookup(Key, [Key/Value | _], const(Value)) :- !.
plookup(Key, [_ | Rest], Value) :- plookup(Key, Rest, Value).

presolve(const(X), _, const(X)).
presolve(var(V), PEnv, X) :- plookup(V, PEnv, X).

plookup
const(Value)
var(Key)
presolve
resolve
plookup
lookup
pe(op1(ResultVar, Op, Arg, Rest), PEnv, NewOp) :-
    presolve(Arg, PEnv, RArg),
    (RArg = const(C) ->
        do_op(Op, C, Res),
        write_env(PEnv, ResultVar, Res, NEnv),
        RestResidual = NewOp
    ;
        remove_env(PEnv, ResultVar, NEnv),
        NewOp = op1(ResultVar, Op, RArg, RestResidual)
    ),
    pe(Rest, NEnv, RestResidual).

pe(op2(ResultVar, Op, Arg1, Arg2, Rest), PEnv, NewOp) :-
    presolve(Arg1, PEnv, RArg1),
    presolve(Arg2, PEnv, RArg2),
    (RArg1 = const(C1), RArg2 = const(C2) ->
        do_op(Op, C1, C2, Res),
        write_env(PEnv, ResultVar, Res, NEnv),
        RestResidual = NewOp

    ;
        remove_env(PEnv, ResultVar, NEnv),
        NewOp = op2(ResultVar, Op, RArg1, RArg2, RestResidual)
    ),
    pe(Rest, NEnv, RestResidual).

pe
NewOp
print_and_stop
pe(jump(L), PEnv, jump(LR)) :-
    do_pe(L, PEnv, LR).

pe(print_and_stop(Arg), Env, print_and_stop(RArg)) :-
    presolve(Arg, Env, RArg).

L
print_and_stop
print_and_stop
do_pe
pe(if(V, L1, L2), PEnv, NewOp) :-
    plookup(V, PEnv, Val),
    (Val = const(C) ->
        (C = 0 ->
            L = L2
        ;
            L = L1
        ),
        do_pe(L, PEnv, LR),
        NewOp = jump(LR)
    ;
        do_pe(L1, PEnv, L1R),
        do_pe(L2, PEnv, L2R),
        NewOp = if(V, L1R, L2R)
    ).

if
do_pe
Label, Partial Environment
Label of the residual
code
do_pe(L, PEnv, LR) :-
    (code_cache(L, PEnv, LR) ->
        true
    ;
        gensym(L, LR),
        assert(code_cache(L, PEnv, LR)),
        block(L, Code),
        pe(Code, PEnv, Residual),
        assert(block(LR, Residual))
    ).

L
PEnv
LPrevious
gensym
assert
y
x
?- do_pe(power, [y/5], LR).
LR = power1.

listing
?- listing(code_cache)
code_cache(power, [y/5], power1).
code_cache(power_rec, [y/5, res/1], power_rec1).
code_cache(power_rec, [y/4], power_rec2).
code_cache(power_rec, [y/3], power_rec3).
code_cache(power_rec, [y/2], power_rec4).
code_cache(power_rec, [y/1], power_rec5).
code_cache(power_done, [y/0], power_done1).

?- listing(block)
.... the block definition of the user program ....
block(power_done1, print_and_stop(var(res))).
block(power_rec5, op2(res, mul, var(res), var(x), jump(power_done1))).
block(power_rec4, op2(res, mul, var(res), var(x), jump(power_rec5))).
block(power_rec3, op2(res, mul, var(res), var(x), jump(power_rec4))).
block(power_rec2, op2(res, mul, var(res), var(x), jump(power_rec3))).
block(power_rec1, op2(res, mul, const(1), var(x), jump(power_rec2))).
block(power1, jump(power_rec1)).

code_cache
power1
power
y
power1
res
x
x
y
:-)
int*
inline-laplace.c
laplace.c
gcc 4.4.5
-O3
laplace.py
inline_slow_time_step
slow_time_step
slow_2_time_step
numeric_time_step
u[1:-1, 1:-1] = ((u[0:-2, 1:-1] + u[2:, 1:-1])*dy2 +
                       (u[1:-1,0:-2] + u[1:-1, 2:])*dx2)*dnr_inv

+
*
numeric_2_time_step
src = self.u
self.u = src.copy()
self.u[1:-1, 1:-1] = ((src[0:-2, 1:-1] + src[2:, 1:-1])*dy2 +
                      (src[1:-1,0:-2] + src[1:-1, 2:])*dx2)*dnr_inv

numeric_3_time_step
src = self.u
self.u = numpy.zeros((self.nx, self.ny), 'd')
self.u[0] = src[0]
self.u[-1] = src[-1]
self.u[:, 0] = src[:, 0]
self.u[:, -1] = src[:, -1]
self.u[1:-1, 1:-1] = ((src[0:-2, 1:-1] + src[2:, 1:-1])*dy2 +
                      (src[1:-1,0:-2] + src[1:-1, 2:])*dx2)*dnr_inv

numeric_4_time_step
remove_invalidates
remove_invalidates(self.old_u)
remove_invalidates(self.u)
self.old_u[:,:] = self.u
src = self.old_u
self.u[1:-1, 1:-1] = ((src[0:-2, 1:-1] + src[2:, 1:-1])*dy2 +
                      (src[1:-1,0:-2] + src[1:-1, 2:])*dx2)*dnr_inv

numeric_5_time_step
remove_invalidates(self.old_u)
remove_invalidates(self.u)
src = self.u
self.old_u, self.u = self.u, self.old_u
self.u[0] = src[0]
self.u[-1] = src[-1]
self.u[:, 0] = src[:, 0]
self.u[:, -1] = src[:, -1]
self.u[1:-1, 1:-1] = ((src[0:-2, 1:-1] + src[2:, 1:-1])*dy2 +
                      (src[1:-1,0:-2] + src[1:-1, 2:])*dx2)*dnr_inv

gcc 4.4.5
-O3
numpypy
#!/usr/bin/env pypy

# numpy, pypy version
import numpypy as numpy
# DRAGONS LIVE THERE (fortunately hidden)
from embed.emb import import_mod

pylab = import_mod('matplotlib.pylab')

if __name__ == '__main__':
    a = numpy.arange(100, dtype=int)
    b = numpy.sin(a)
    pylab.plot(a, b)
    pylab.show()

./translate.py -Ojit targetpypystandalone.py --withoutmod-cpyext

PYTHONPATH
PYTHONPATH
import numpypy as numpy

ctypes.Structure
file.readlines()
f2py
ctypes
f2pypy
long
void*
__pypy__.builders.StringBuilder
str.join()
cStringIO
__pypy__.builders.UnicodeBuilder
re.sub
builder.append
iterencode
for c in s: # s is string
  del c

for c in s:
  pass

dtype
==
>
numpy.array([True], dtype=bool)[0]
bool
numpy.bool_
W_<type>Objects
W_StringObject to represent strings, W_IntObject
W_ListObject
W_ListObject
rerased
void-star
Object
W_ListObject
storage
storage = erase([1 ,2 ,3 ,4])
# storage is an opaque object that you can do nothing with
....
l = unerase(storage)
l.clear()

W_ListObject
W_ListObject
ListStrategy
W_ListObject
ListStrategy
W_ListObject
IntegerListStrategy
ObjectListStrategy
Strategy
EmptyListStrategy
None
RangeListsStrategies
IntegerStrategy
CPython, PyPy
PyPy-list
CPython
xrange
append
delete
cppyy
reflex-support
cpyext
cppyy
cppyy
pypy-c
cppyy
next_item = global_list.pop()

Thread 1:  set1.update(set2)
Thread 2:  set2.update(set3)
Thread 3:  set3.update(set1)
with atomic:
    <these operations are executed atomically>

array('f')
pip
distribute
pip install jitviewer
pip
flask
jinja2
def f(a, b):
   return a + b

import dis
dis.dis(f)

LOAD_FAST
LOAD_GLOBAL
+
"%d %d" % (i, i)
char x[44];
sprintf(x, "%d %d", i, i);

x
char *x = malloc(44 * sizeof(char));
sprintf(x, "%d %d", i, i);

x
unroll-if-alt
def main():
    for i in xrange(10000000):
        "%d %d" % (i, i)

main()

#include <stdio.h>
#include <stdlib.h>

int main() {
    int i = 0;
    char x[44];
    for (i = 0; i < 10000000; i++) {
        sprintf(x, "%d %d", i, i);
    }
}

unroll-if-alt
sprintf
#include <stdio.h>
#include <stdlib.h>

int main() {
    int i = 0;
    for (i = 0; i < 10000000; i++) {
        char *x = malloc(44 * sizeof(char));
        sprintf(x, "%d %d", i, i);
        free(x);
    }
}

sobel.py
magnify.py
mplayer
$ pypy pypy-image-demo/sobel.py

$ pypy pypy-image-demo/magnify.py

$ pypy demo/sobel.py tv://

$ pypy demo/magnify.py -b

magnify.py
sobel.py
test.avi
sobel.py
magnify.py
sobel.py
magnify.py
def f(list1, list2):
    x = list1.pop()
    list2.append(x)

f(l1, l2)
f(l2, l1)
def f(list1, list2):
    global_lock.acquire()
    x = list1.pop()
    list2.append(x)
    global_lock.release()

def f(list1, list2):
    acquire_all_locks(list1.lock, list2.lock)
    x = list1.pop()
    list2.append(x)
    release_all_locks(list1.lock, list2.lock)

def f(list1, list2):
    while True:
        t = transaction()
        x = list1.pop(t)
        list2.append(t, x)
        if t.commit():
            break

transaction
transaction
transation

bench	number of iterations	time per iteration
laplace C	219	6.3ms
inline-laplace C	278	20ms
slow python	219	17ms
slow 2 python	219	14ms
inline_slow python	278	23.7ms

benchmark	PyPy	CPython
numeric	21ms	35ms
numeric 2	14ms	37ms
numeric 3	13ms	29ms
numeric 4	11ms	31ms
numeric 5	9.3ms	21ms

CPython 2.6	22s
CPython 2.7	3.7s
CPython 2.7 no C extension	44s
PyPy 1.5	34s
PyPy 1.6	22s
PyPy trunk	3.3s

Platform	GCC (stack)	GCC (malloc)	CPython	PyPy (unroll-if-alt)
Time	1.63s	1.96s	10.2s	0.85s
relative to C	1x	0.83x	0.16x	1.9x

PyPy Status Blog

NumPyPy status update

Py3k and Numpy First Stage: Thanks to all who Gave

Comparing Partial Evaluation and Tracing, Part 1

A Flowgraph Language

Partial Evaluation of the Flowgraph Language

Partial Evaluation Example

Conclusion

PyPy internship at NCAR

Transactional Memory (II)

Threads or Events?

The problem

Events in Transactions

Not a perfect solution

One step towards the future?

NumPyPy progress report - running benchmarks

Benchmark

Leysin Winter Sprint

PyPy Leysin Winter Sprint: 15-22nd January 2012

Goals and topics of the sprint

Exact times

Come see us at PyCon 2012

Plotting using matplotlib from PyPy

Er wait, what happened?

PyPy 1.7 on Win32

PyPy 1.7 - widening the sweet spot

What is PyPy?

Highlights

Things that didn't make it, expect in 1.8 soon

Fundraising

Gothenburg sprint report

Speeding up JSON encoding in PyPy

Expectations are high

Often interface between the C and Python part is ugly

JitViewer is crucial

No nice and fast way to build strings in Python

Method calls are ok, immutable globals are ok

String copying is expensive

Generators are slower than they should be

I must admit I worked around PyPy's performance bug

PyPy's JIT is good

PyPy Göteborg Post-Hallowe'en Sprint Nov 2nd - Nov 9th

Other Useful dates

Location

Good to Know

Getting Here

Who's Coming?

Numpy funding and status update

More Compact Lists with List Strategies

List Strategies

Microbenchmarks

Conclusion

Py3k for PyPy fundraiser

Wrapping C++ Libraries with Reflection — Status Report One Year Later

We need Software Transactional Memory

The problem in complex high-level languages

Jython: fine-grained locking

CPython: coarse-grained locking

Existing usage

PyPy

Using Software Transactional Memory

Performance

The state of STM

Conclusion

PyPy 1.6 - kickass panda

What is PyPy?

Highlights

Visualization of JITted code

What does the jitviewer really do?

I'm still confused

PyPy is faster than C, again: string formatting

Realtime image processing in Python

Global Interpreter Lock, or how to kill it

Report back from our survey