PyPy Use Case and Experiment

This is my slide at PyCon TW 2017, topic is "PyPy's approach to construct domain-specific language runtime", and this slide contains some experiments and benchmark related to PyPy, a JIT-enabled version of Python

Transcript

1. Use Case / Experiment TsundereChen
2. Test Environment • Vagrant, Ubuntu/16.04 • The benchmark result on Host OS and Guest OS is really close, so I use VM to get result
 (BTW, it's really easy to get your VM dirty
3. Test Version • CPython2 2.7.12 • CPython3 3.5.2 • PyPy2 5.1.2 (Installed from apt-get) • PyPy2 5.6.0 (Compiled from source) • PyPy3 5.7.1 (Compiled from source)
4. Why only CPython & PyPy • Cython • You'll need to learn Cython's syntax, it's mixing C and Python. • Jython • The latest version of Jython 2.7.0 is released in May 2015, so it's outdated
5. Some notice • PyPy3 is still in beta, so if it's slower than CPython 3, no surprise • And not every module can run faster in PyPy than CPython, there will be samples later
6. Why PyPy3 is beta ? • The way CPython develop and the way PyPy develop is different • CPython • Focus on Python3, only maintain Python2 when security issue pops up • PyPy • Focus on PyPy2, also updating PyPy3, but it's not their main development
7. How to run PyPy
8. PyPy Installation • pypy.org/download.html • If you download binary • run bin/pypy
9. PyPy Installation • If you want to compile PyPy from scratch • First, install dependencies • http://doc.pypy.org/en/latest/build.html • Then, cd to pypy/goal
10. PyPy Installation • No-JIT • <Python/PyPy> ../../rpython/bin/rpython -- opt=2 • JIT-Enabled • <Python/PyPy> ../../rpython/bin/rpython -- opt=jit
11. PyPy Installation • Notice • Compile PyPy takes lots of time, and compile it with JIT-Enabled takes even more. • Usually takes 30min up • And you need at least 4G RAM to compile it on 64-Bit Machine, make sure you have enough RAM for this, or it may be killed by system
12. Mandelbrot — For Fun
13. Benchmark result
14. gcbench
15. json_bench
16. django_template
17. nqueens
18. regex_v8
19. richards
20. scimark
21. sqlalchemy_declarative
22. sqlalchemy_imperative
23. So, why do we still need CPython?
24. Not every case should use PyPy • For example, when it comes to the code below, CPython is faster than PyPy
 myStr = “”
 for x in xrange(1, 10**6):
 myStr += str(myStr[x])
25. Can <package> run on PyPy? http://packages.pypy.org/
26. Enough benchmark, let's get to DSL
27. Example • Language: Brainf*ck • 8 commands • + mem[ptr] += 1 - mem[ptr] -= 1
 < ptr -= 1 > ptr += 1
 , input() . print()
 [ while(mem[ptr]){ ] }
28. Repo for Brainf*ck experiment • https://github.com/TsundereChen/bf_to_py
29. Our Goal • Build a Brainf*ck Interpreter • Build a Brainf*ck to Python translator, and compile it with PyPy
30. Interpreter • Just read in the file, and execute the command • But, we can add JIT here
31. What to do to add JIT • We need to find "Reds" and "Greens" • Greens -> Define instructions • Reds -> What's being manipulated
32. What to do to add JIT • from rpython.rlib.jit import JitDriver • jitdriver = JitDriver(greens=[], reds=[]) • and add jit_merge_point to your main loop
33. Difference Hm....Not very good, right ? Notice the second It’s 2.73… v.s 2.61…
34. JIT is not enough...
 How about some opts
35. Optimize • Speed up loop • Because every loop needs to look up address in dictionary, but the dictionary is static, so we can use @elidable decorator and add a function to speed up
36. Difference Hmm.... Better
37. Difference Hmm.... Better
38. Difference Hmm.... Better
39. Difference Hmm.... Better
40. Okay...enough interpreter
 Let's talk about compiler
41. Basic Knowledge • It reads in Brainf*ck file, then turn into IR • Then you can choose to do Optimize in IR • Finally, turn your IR into Python Code, and compile it with PyPy to generate a binary file Brainf*ck Code IR Python Code Binary File
42. Architecture • ir.py -> For Brainf*ck to IR and IR to Python • trans.py -> Main program • python trans.py <input> <output> <optmode> • optmode 1 to open optimization, 0 to not to • opt.py -> Optimize tricks
43. Optimizations • opt_contract ( Contract) • Operation like " +++++ ", means that we have to do "mem[p] += 1" five times • But because we have IR, so we can change the instruction to "mem[p] += 5" • When it comes to “+ - > <“, this trick can apply
44. Optimizations • opt_clearloop (Clear Loop) • Command like [-], it means when(mem[p]), do mem[p] -= 1 • We know what the result is, so we can set mem[p] to zero directly
 mem[p] = 0
45. Optimizations • opt_multiloop & opt_copyloop (Multiplication and Copy) • Command like [->+>+<<] is copy mem[p]'s value to mem[p+1] and mem[p+2], and set mem[p] to zero • If we know what this is doing, we can make it short
46. Optimizations • opt_multiloop & opt_copyloop (Multiplication and Copy) • Same trick can apply to [->++<], make
 mem[p+1] = 2 * mem[p] and set mem[p] = 0 • Which is multiplication
47. Optimizations • opt_offsetops (Operation Offsets) • In Brainf*ck, we know that we have a pointer indicating where we are now, and pointer usually move a lot • What if we can calculate offset for Instructions directly, so we don't need to move the pointer around
48. Optimizations • opt_cancel (Cancel Instructions) • ++++-->>+-<<< do the same thing as ++< • Then, why waste all the time on these Instructons ?
49. Can it run faster ? Yes — JIT
50. Result
51. Result
52. Result
53. Result
54. Great! So I'll use JIT from now on
55. Wait a sec... • Not every case can use JIT • Because JIT needs to warm-up and Analysis
 Maybe warm-up can take more time than your code actually run • And it's import to avoid to record the warm-up time when you want to do some benchmarking
56. Wait a sec... • And do you really need JIT ? • It may cost a lot for one to import JIT to a project • Sometimes, maybe buy more server is a better choice than import JIT into your project
57. Wait a sec... • But if you analyzed your project, know how difficult it is for you to import PyPy and JIT into your project, then you're good to go! • BTW, file size of executable with JIT Enabled is bigger than the one with No-JIT
58. Question?
59. References • Tutorial: Writing an Interpreter with PyPy, part 1 • https://morepypy.blogspot.tw/2011/04/tutorial-writing-interpreter-with- pypy.html • PyPy - Tutorial for Brainf*ck Interpreter • http://wdv4758h.github.io/posts/2015/01/pypy-tutorial-for-brainfuck- interpreter/ • matslina/bfoptimization • https://github.com/matslina/bfoptimization/ • Virtual Machine Constructions for Dummies • https://www.slideshare.net/jserv/vm-construct