[pypy-commit] extradoc extradoc: merge
fijal
noreply at buildbot.pypy.org
Wed Jul 4 16:14:34 CEST 2012
Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: extradoc
Changeset: r4279:b3b112288b65
Date: 2012-07-04 16:14 +0200
http://bitbucket.org/pypy/extradoc/changeset/b3b112288b65/
Log: merge
diff --git a/.hgignore b/.hgignore
--- a/.hgignore
+++ b/.hgignore
@@ -1,3 +1,11 @@
syntax: glob
*.py[co]
*~
+talk/ep2012/stackless/slp-talk.aux
+talk/ep2012/stackless/slp-talk.latex
+talk/ep2012/stackless/slp-talk.log
+talk/ep2012/stackless/slp-talk.nav
+talk/ep2012/stackless/slp-talk.out
+talk/ep2012/stackless/slp-talk.snm
+talk/ep2012/stackless/slp-talk.toc
+talk/ep2012/stackless/slp-talk.vrb
\ No newline at end of file
diff --git a/talk/ep2012/stackless/Makefile b/talk/ep2012/stackless/Makefile
new file mode 100644
--- /dev/null
+++ b/talk/ep2012/stackless/Makefile
@@ -0,0 +1,15 @@
+# you can find rst2beamer.py here:
+# http://codespeak.net/svn/user/antocuni/bin/rst2beamer.py
+
+slp-talk.pdf: slp-talk.rst author.latex title.latex stylesheet.latex
+ rst2beamer.py --stylesheet=stylesheet.latex --documentoptions=14pt slp-talk.rst slp-talk.latex || exit
+ sed 's/\\date{}/\\input{author.latex}/' -i slp-talk.latex || exit
+ sed 's/\\maketitle/\\input{title.latex}/' -i slp-talk.latex || exit
+ sed 's/\\usepackage\[latin1\]{inputenc}/\\usepackage[utf8]{inputenc}/' -i slp-talk.latex || exit
+ pdflatex slp-talk.latex || exit
+
+view: slp-talk.pdf
+ evince talk.pdf &
+
+xpdf: slp-talk.pdf
+ xpdf slp-talk.pdf &
diff --git a/talk/ep2012/stackless/author.latex b/talk/ep2012/stackless/author.latex
new file mode 100644
--- /dev/null
+++ b/talk/ep2012/stackless/author.latex
@@ -0,0 +1,8 @@
+\definecolor{rrblitbackground}{rgb}{0.0, 0.0, 0.0}
+
+\title[The Story of Stackless Python]{The Story of Stackless Python}
+\author[tismer, nagare]
+{Christian Tismer, Hervé Coatanhay}
+
+\institute{EuroPython 2012}
+\date{July 4 2012}
diff --git a/talk/ep2012/stackless/beamerdefs.txt b/talk/ep2012/stackless/beamerdefs.txt
new file mode 100644
--- /dev/null
+++ b/talk/ep2012/stackless/beamerdefs.txt
@@ -0,0 +1,108 @@
+.. colors
+.. ===========================
+
+.. role:: green
+.. role:: red
+
+
+.. general useful commands
+.. ===========================
+
+.. |pause| raw:: latex
+
+ \pause
+
+.. |small| raw:: latex
+
+ {\small
+
+.. |end_small| raw:: latex
+
+ }
+
+.. |scriptsize| raw:: latex
+
+ {\scriptsize
+
+.. |end_scriptsize| raw:: latex
+
+ }
+
+.. |strike<| raw:: latex
+
+ \sout{
+
+.. closed bracket
+.. ===========================
+
+.. |>| raw:: latex
+
+ }
+
+
+.. example block
+.. ===========================
+
+.. |example<| raw:: latex
+
+ \begin{exampleblock}{
+
+
+.. |end_example| raw:: latex
+
+ \end{exampleblock}
+
+
+
+.. alert block
+.. ===========================
+
+.. |alert<| raw:: latex
+
+ \begin{alertblock}{
+
+
+.. |end_alert| raw:: latex
+
+ \end{alertblock}
+
+
+
+.. columns
+.. ===========================
+
+.. |column1| raw:: latex
+
+ \begin{columns}
+ \begin{column}{0.45\textwidth}
+
+.. |column2| raw:: latex
+
+ \end{column}
+ \begin{column}{0.45\textwidth}
+
+
+.. |end_columns| raw:: latex
+
+ \end{column}
+ \end{columns}
+
+
+
+.. |snake| image:: ../../img/py-web-new.png
+ :scale: 15%
+
+
+
+.. nested blocks
+.. ===========================
+
+.. |nested| raw:: latex
+
+ \begin{columns}
+ \begin{column}{0.85\textwidth}
+
+.. |end_nested| raw:: latex
+
+ \end{column}
+ \end{columns}
diff --git a/talk/ep2012/stackless/demo/pickledtasklet.py b/talk/ep2012/stackless/demo/pickledtasklet.py
new file mode 100644
--- /dev/null
+++ b/talk/ep2012/stackless/demo/pickledtasklet.py
@@ -0,0 +1,25 @@
+import pickle, sys
+import stackless
+
+ch = stackless.channel()
+
+def recurs(depth, level=1):
+ print 'enter level %s%d' % (level*' ', level)
+ if level >= depth:
+ ch.send('hi')
+ if level < depth:
+ recurs(depth, level+1)
+ print 'leave level %s%d' % (level*' ', level)
+
+def demo(depth):
+ t = stackless.tasklet(recurs)(depth)
+ print ch.receive()
+ pickle.dump(t, file('tasklet.pickle', 'wb'))
+
+if __name__ == '__main__':
+ if len(sys.argv) > 1:
+ t = pickle.load(file(sys.argv[1], 'rb'))
+ t.insert()
+ else:
+ t = stackless.tasklet(demo)(9)
+ stackless.run()
diff --git a/talk/ep2012/stackless/eurpython-2012.pptx b/talk/ep2012/stackless/eurpython-2012.pptx
new file mode 100644
index 0000000000000000000000000000000000000000..9b34bb66e92cbe27ce5dc5c3928fe9413abf2cef
GIT binary patch
[cut]
diff --git a/talk/ep2012/stackless/logo_small.png b/talk/ep2012/stackless/logo_small.png
new file mode 100644
index 0000000000000000000000000000000000000000..acfe083b78f557c394633ca542688a2bfca6a5e8
GIT binary patch
[cut]
diff --git a/talk/ep2012/stackless/slp-talk.pdf b/talk/ep2012/stackless/slp-talk.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..afcb8c00b73bb83d114dc4e0d9c8ec1157800ef3
GIT binary patch
[cut]
diff --git a/talk/ep2012/stackless/slp-talk.rst b/talk/ep2012/stackless/slp-talk.rst
new file mode 100644
--- /dev/null
+++ b/talk/ep2012/stackless/slp-talk.rst
@@ -0,0 +1,675 @@
+.. include:: beamerdefs.txt
+
+============================================
+The Story of Stackless Python
+============================================
+
+
+About This Talk
+----------------
+
+* first talk after a long break
+
+ - *rst2beamer* for the first time
+
+guest speaker:
+
+* Herve Coatanhay about Nagare
+
+ - PowerPoint (Mac)
+
+|pause|
+
+Meanwhile I used
+
+* Powerpoint (PC)
+
+* Keynote (Mac)
+
+* Google Docs
+
+|pause|
+
+poll: What is your favorite slide tool?
+
+What is Stackless?
+-------------------
+
+* *Stackless is a Python version that does not use the C stack*
+
+ |pause|
+
+ - really? naah
+
+|pause|
+
+* Stackless is a Python version that does not keep state on the C stack
+
+ - the stack *is* used but
+
+ - cleared between function calls
+
+|pause|
+
+* Remark:
+
+ - theoretically. In practice...
+
+ - ... it is reasonable 90 % of the time
+
+ - we come back to this!
+
+
+What is Stackless about?
+-------------------------
+
+* it is like CPython
+
+|pause|
+
+* it can do a little bit more
+
+|pause|
+
+* adds a single builtin module
+
+|pause|
+
+|scriptsize|
+|example<| |>|
+
+ .. sourcecode:: python
+
+ import stackless
+
+|end_example|
+|end_scriptsize|
+
+|pause|
+
+* is like an extension
+
+ - but, sadly, not really
+
+ - stackless **must** be builtin
+
+ - **but:** there is a solution...
+
+
+Now, what is it really about?
+------------------------------
+
+* have tiny little "main" programs
+
+ - ``tasklet``
+
+|pause|
+
+* tasklets communicate via messages
+
+ - ``channel``
+
+|pause|
+
+* tasklets are often called ``microthreads``
+
+ - but there are no threads at all
+
+ - only one tasklets runs at any time
+
+|pause|
+
+* *but see the PyPy STM* approach
+
+ - this will apply to tasklets as well
+
+
+Cooperative Multitasking ...
+-------------------------------
+
+|scriptsize|
+|example<| |>|
+
+ .. sourcecode:: pycon
+
+ >>> import stackless
+ >>>
+ >>> channel = stackless.channel()
+
+|pause|
+
+ .. sourcecode:: pycon
+
+ >>> def receiving_tasklet():
+ ... print "Receiving tasklet started"
+ ... print channel.receive()
+ ... print "Receiving tasklet finished"
+
+|pause|
+
+ .. sourcecode:: pycon
+
+ >>> def sending_tasklet():
+ ... print "Sending tasklet started"
+ ... channel.send("send from sending_tasklet")
+ ... print "sending tasklet finished"
+
+|end_example|
+|end_scriptsize|
+
+
+... Cooperative Multitasking ...
+---------------------------------
+
+|scriptsize|
+|example<| |>|
+
+ .. sourcecode:: pycon
+
+ >>> def another_tasklet():
+ ... print "Just another tasklet in the scheduler"
+
+|pause|
+
+ .. sourcecode:: pycon
+
+ >>> stackless.tasklet(receiving_tasklet)()
+ <stackless.tasklet object at 0x00A45B30>
+ >>> stackless.tasklet(sending_tasklet)()
+ <stackless.tasklet object at 0x00A45B70>
+ >>> stackless.tasklet(another_tasklet)()
+ <stackless.tasklet object at 0x00A45BF0>
+
+|end_example|
+|end_scriptsize|
+
+
+... Cooperative Multitasking
+-------------------------------
+
+|scriptsize|
+|example<| |>|
+
+ .. sourcecode:: pycon
+
+ <stackless.tasklet object at 0x00A45B70>
+ >>> stackless.tasklet(another_tasklet)()
+ <stackless.tasklet object at 0x00A45BF0>
+ >>>
+ >>> stackless.run()
+ Receiving tasklet started
+ Sending tasklet started
+ send from sending_tasklet
+ Receiving tasklet finished
+ Just another tasklet in the scheduler
+ sending tasklet finished
+
+|end_example|
+|end_scriptsize|
+
+
+Why not just the *greenlet* ?
+-------------------------------
+
+* greenlets are a subset of stackless
+
+ - can partially emulate stackless
+
+ - there is no builtin scheduler
+
+ - technology quite close to Stackless 2.0
+
+|pause|
+
+* greenlets are about 10x slower to switch context because
+ using only hard-switching
+
+ - but that's ok in most cases
+
+|pause|
+
+* greenlets are kind-of perfect
+
+ - near zero maintenace
+
+ - minimal interface
+
+|pause|
+
+* but the main difference is ...
+
+
+Excurs: Hard-Switching
+-----------------------
+
+Sorry ;-)
+
+Switching program state "the hard way":
+
+Without notice of the interpreter
+
+* the machine stack gets hijacked
+
+ - Brute-Force: replace the stack with another one
+
+ - like threads
+
+* stackless, greenlets
+
+ - stack slicing
+
+ - semantically same effect
+
+* switching works fine
+
+* pickling does not work, opaque data on the stack
+
+ - this is more sophisticated in PyPy, another story...
+
+
+Excurs: Soft-Switching
+-----------------------
+
+Switching program state "the soft way":
+
+With knowledge of the interpreter
+
+* most efficient implementation in Stackless 3.1
+
+* demands the most effort of the developers
+
+* no opaque data on the stack, pickling does work
+
+ - again, this is more sophisticated in PyPy
+
+|pause|
+
+* now we are at the main difference, as you guessed ...
+
+
+Pickling Program State
+-----------------------
+
+|scriptsize|
+|example<| Persistence (p. 1 of 2) |>|
+
+ .. sourcecode:: python
+
+ import pickle, sys
+ import stackless
+
+ ch = stackless.channel()
+
+ def recurs(depth, level=1):
+ print 'enter level %s%d' % (level*' ', level)
+ if level >= depth:
+ ch.send('hi')
+ if level < depth:
+ recurs(depth, level+1)
+ print 'leave level %s%d' % (level*' ', level)
+
+|end_example|
+
+# *remember to show it interactively*
+
+|end_scriptsize|
+
+
+Pickling Program State
+-----------------------
+
+|scriptsize|
+
+|example<| Persistence (p. 2 of 2) |>|
+
+ .. sourcecode:: python
+
+
+ def demo(depth):
+ t = stackless.tasklet(recurs)(depth)
+ print ch.receive()
+ pickle.dump(t, file('tasklet.pickle', 'wb'))
+
+ if __name__ == '__main__':
+ if len(sys.argv) > 1:
+ t = pickle.load(file(sys.argv[1], 'rb'))
+ t.insert()
+ else:
+ t = stackless.tasklet(demo)(9)
+ stackless.run()
+
+
+|end_example|
+
+# *remember to show it interactively*
+
+|end_scriptsize|
+
+
+Script Output 1
+-----------------
+
+|example<| |>|
+|scriptsize|
+
+ .. sourcecode:: pycon
+
+ $ ~/src/stackless/python.exe demo/pickledtasklet.py
+ enter level 1
+ enter level 2
+ enter level 3
+ enter level 4
+ enter level 5
+ enter level 6
+ enter level 7
+ enter level 8
+ enter level 9
+ hi
+ leave level 9
+ leave level 8
+ leave level 7
+ leave level 6
+ leave level 5
+ leave level 4
+ leave level 3
+ leave level 2
+ leave level 1
+
+|end_scriptsize|
+|end_example|
+
+
+Script Output 2
+-----------------
+
+|example<| |>|
+|scriptsize|
+
+ .. sourcecode:: pycon
+
+ $ ~/src/stackless/python.exe demo/pickledtasklet.py tasklet.pickle
+ leave level 9
+ leave level 8
+ leave level 7
+ leave level 6
+ leave level 5
+ leave level 4
+ leave level 3
+ leave level 2
+ leave level 1
+
+|end_scriptsize|
+|end_example|
+
+
+Greenlet vs. Stackless
+-----------------------
+
+* Greenlet is a pure extension module
+
+ - but performance is good enough
+
+|pause|
+
+* Stackless can pickle program state
+
+ - but stays a replacement of Python
+
+|pause|
+
+* Greenlet never can, as an extension
+
+|pause|
+
+* *easy installation* lets people select greenlet over stackless
+
+ - see for example the *eventlet* project
+
+ - *but there is a simple work-around, we'll come to it*
+
+|pause|
+
+* *they both have their application domains
+ and they will persist.*
+
+
+Why Stackless makes a Difference
+---------------------------------
+
+* Microthreads ?
+
+ - the feature where I put most effort into
+
+ |pause|
+
+ - can be emulated: (in decreasing speed order)
+
+ - generators (incomplete, "half-sided")
+
+ - greenlet
+
+ - threads (even ;-)
+
+|pause|
+
+* Pickling program state ! ==
+
+|pause|
+
+* **persistence**
+
+
+Persistence, Cloud Computing
+-----------------------------
+
+* freeze your running program
+
+* let it continue anywhere else
+
+ - on a different computer
+
+ - on a different operating system (!)
+
+ - in a cloud
+
+* migrate your running program
+
+* save snapshots, have checkpoints
+
+ - without doing any extra-work
+
+
+Software archeology
+-------------------
+
+* Around since 1998
+
+ - version 1
+
+ - using only soft-switching
+
+ - continuation-based
+
+ - *please let me skip old design errors :-)*
+
+|pause|
+
+* Complete redesign in 2002
+
+ - version 2
+
+ - using only hard-switching
+
+ - birth of tasklets and channels
+
+|pause|
+
+* Concept merge in 2004
+
+ - version 3
+
+ - **80-20** rule:
+
+ - soft-switching whenever possible
+
+ - hard-switching if foreign code is on the stack
+
+ - these 80 % can be *pickled* (90?)
+
+* This stayed as version 3.1
+
+Status of Stackless Python
+---------------------------
+
+* mature
+
+* Python 2 and Python 3, all versions
+
+* maintained by
+
+ - Richard Tew
+ - Kristjan Valur Jonsson
+ - me (a bit)
+
+
+The New Direction for Stackless
+-------------------------------
+
+* ``pip install stackless-python``
+
+ - will install ``slpython``
+ - or even ``python`` (opinions?)
+
+|pause|
+
+* drop-in replacement of CPython
+ *(psssst)*
+
+|pause|
+
+* ``pip uninstall stackless-python``
+
+ - Stackless is a bit cheating, as it replaces the python binary
+
+ - but the user perception will be perfect
+
+* *trying stackless made easy!*
+
+
+New Direction (cont'd)
+-----------------------
+
+* first prototype yesterday from
+
+ Anselm Kruis *(applause)*
+
+ - works on Windows
+
+ |pause|
+
+ - OS X
+
+ - I'll do that one
+
+ |pause|
+
+ - Linux
+
+ - soon as well
+
+|pause|
+
+* being very careful to stay compatible
+
+ - python 2.7.3 installs stackless for 2.7.3
+ - python 3.2.3 installs stackless for 3.2.3
+
+ - python 2.7.2 : *please upgrade*
+ - or maybe have an over-ride option?
+
+Consequences of the Pseudo-Package
+-----------------------------------
+
+The technical effect is almost nothing.
+
+The psycological impact is probably huge:
+
+|pause|
+
+* stackless is easy to install and uninstall
+
+|pause|
+
+* people can simply try if it fits their needs
+
+|pause|
+
+* the never ending discussion
+
+ - "Why is Stackless not included in the Python core?"
+
+|pause|
+
+* **has ended**
+
+ - "Why should we, after all?"
+
+ |pause|
+
+ - hey Guido :-)
+
+ - what a relief, for you and me
+
+
+Status of Stackless PyPy
+---------------------------
+
+* was completely implemented before the Jit
+
+ - together with
+ greenlets
+ coroutines
+
+ - not Jit compatible
+
+* was "too complete" with a 30% performance hit
+
+* new approach is almost ready
+
+ - with full Jit support
+ - but needs some fixing
+ - this *will* be efficient
+
+Applications using Stackless Python
+------------------------------------
+
+* The Eve Online MMORPG
+
+ http://www.eveonline.com/
+
+ - based their games on Stackless since 1998
+
+* science + computing ag, Anselm Kruis
+
+ https://ep2012.europython.eu/conference/p/anselm-kruis
+
+* The Nagare Web Framework
+
+ http://www.nagare.org/
+
+ - works because of Stackless Pickling
+
+* today's majority: persistence
+
+
+Thank you
+---------
+
+* the new Stackless Website
+ http://www.stackless.com/
+
+ - a **great** donation from Alain Pourier, *Nagare*
+
+* You can hire me as a consultant
+
+* Questions?
diff --git a/talk/ep2012/stackless/stylesheet.latex b/talk/ep2012/stackless/stylesheet.latex
new file mode 100644
--- /dev/null
+++ b/talk/ep2012/stackless/stylesheet.latex
@@ -0,0 +1,11 @@
+\usetheme{Boadilla}
+\usecolortheme{whale}
+\setbeamercovered{transparent}
+\setbeamertemplate{navigation symbols}{}
+
+\definecolor{darkgreen}{rgb}{0, 0.5, 0.0}
+\newcommand{\docutilsrolegreen}[1]{\color{darkgreen}#1\normalcolor}
+\newcommand{\docutilsrolered}[1]{\color{red}#1\normalcolor}
+
+\newcommand{\green}[1]{\color{darkgreen}#1\normalcolor}
+\newcommand{\red}[1]{\color{red}#1\normalcolor}
diff --git a/talk/ep2012/stackless/title.latex b/talk/ep2012/stackless/title.latex
new file mode 100644
--- /dev/null
+++ b/talk/ep2012/stackless/title.latex
@@ -0,0 +1,5 @@
+\begin{titlepage}
+\begin{figure}[h]
+\includegraphics[width=60px]{logo_small.png}
+\end{figure}
+\end{titlepage}
diff --git a/talk/ep2012/stm/stmdemo2.py b/talk/ep2012/stm/stmdemo2.py
--- a/talk/ep2012/stm/stmdemo2.py
+++ b/talk/ep2012/stm/stmdemo2.py
@@ -1,33 +1,37 @@
- def specialize_more_blocks(self):
- while True:
- # look for blocks not specialized yet
- pending = [block for block in self.annotator.annotated
- if block not in self.already_seen]
- if not pending:
- break
+def specialize_more_blocks(self):
+ while True:
+ # look for blocks not specialized yet
+ pending = [block for block in self.annotator.annotated
+ if block not in self.already_seen]
+ if not pending:
+ break
- # specialize all blocks in the 'pending' list
- for block in pending:
- self.specialize_block(block)
- self.already_seen.add(block)
+ # specialize all blocks in the 'pending' list
+ for block in pending:
+ self.specialize_block(block)
+ self.already_seen.add(block)
- def specialize_more_blocks(self):
- while True:
- # look for blocks not specialized yet
- pending = [block for block in self.annotator.annotated
- if block not in self.already_seen]
- if not pending:
- break
- # specialize all blocks in the 'pending' list
- # *using transactions*
- for block in pending:
- transaction.add(self.specialize_block, block)
- transaction.run()
- self.already_seen.update(pending)
+
+
+def specialize_more_blocks(self):
+ while True:
+ # look for blocks not specialized yet
+ pending = [block for block in self.annotator.annotated
+ if block not in self.already_seen]
+ if not pending:
+ break
+
+ # specialize all blocks in the 'pending' list
+ # *using transactions*
+ for block in pending:
+ transaction.add(self.specialize_block, block)
+ transaction.run()
+
+ self.already_seen.update(pending)
diff --git a/talk/ep2012/stm/talk.pdf b/talk/ep2012/stm/talk.pdf
index 19067d178980accc5a060fa819059611fcf1acdc..59ba6454817cd0a87accdf48e505190fe99b4924
GIT binary patch
[cut]
diff --git a/talk/ep2012/stm/talk.rst b/talk/ep2012/stm/talk.rst
--- a/talk/ep2012/stm/talk.rst
+++ b/talk/ep2012/stm/talk.rst
@@ -484,6 +484,8 @@
* http://pypy.org/
-* You can hire Antonio
+* You can hire Antonio (http://antocuni.eu)
* Questions?
+
+* PyPy help desk on Thursday morning
\ No newline at end of file
diff --git a/talk/vmil2012/paper.tex b/talk/vmil2012/paper.tex
--- a/talk/vmil2012/paper.tex
+++ b/talk/vmil2012/paper.tex
@@ -104,10 +104,10 @@
The contributions of this paper are:
\begin{itemize}
- \item
+ \item
\end{itemize}
-The paper is structured as follows:
+The paper is structured as follows:
\section{Background}
\label{sec:Background}
@@ -116,6 +116,34 @@
\label{sub:pypy}
+The RPython language and the PyPy Project were started in 2002 with the goal of
+creating a python interpreter written in a High level language, allowing easy
+language experimentation and extension. PyPy is now a fully compatible
+alternative implementation of the Python language, xxx mention speed. The
+Implementation takes advantage of the language features provided by RPython
+such as the provided tracing just-in-time compiler described below.
+
+RPython, the language and the toolset originally developed to implement the
+Python interpreter have developed into a general environment for experimenting
+and developing fast and maintainable dynamic language implementations. xxx Mention
+the different language impls.
+
+RPython is built of two components, the language and the translation toolchain
+used to transform RPython programs to executable units. The RPython language
+is a statically typed object oriented high level language. The language provides
+several features such as automatic memory management (aka. Garbage Collection)
+and just-in-time compilation. When writing an interpreter using RPython the
+programmer only has to write the interpreter for the language she is
+implementing. The second RPython component, the translation toolchain, is used
+to transform the program to a low level representations suited to be compiled
+and run on one of the different supported target platforms/architectures such
+as C, .NET and Java. During the transformation process
+different low level aspects suited for the target environment are automatically
+added to program such as (if needed) a garbage collector and with some hints
+provided by the author a just-in-time compiler.
+
+
+
\subsection{PyPy's Meta-Tracing JIT Compilers}
\label{sub:tracing}
@@ -134,7 +162,7 @@
* High level handling of resumedata
* trade-off fast tracing v/s memory usage
- * creation in the frontendÂ
+ * creation in the frontendÂ
* optimization
* compression
* interaction with optimization
More information about the pypy-commit
mailing list