À propos de Pyston

Pyston est une implémentation compatible de Python 2.7 créée avec DropBox. Il semble que la mise en œuvre est encouragée pour améliorer les performances en utilisant LLVM et la technologie JIT moderne. Consultez l'article suivant pour plus de détails.

https://tech.dropbox.com/2014/04/introducing-pyston-an-upcoming-jit-based-python-implementation/
http://news.mynavi.jp/news/2014/04/11/041/

 With those caveats, Pyston generally is able to beat CPython’s performance, but still lags behind PyPy.

"Fonctionne mieux que CPython, mais pas aussi bonne que PyPy."

Au fait, il semble qu'il cible actuellement la plate-forme de l'environnement Ubuntu + x86_amd64.

Construire

À l'heure actuelle (au 15 avril 2014), le binaire n'est pas publié, vous devez donc le créer vous-même. Vous pouvez le construire grossièrement en vous référant à ce qui suit.

https://github.com/dropbox/pyston/blob/master/README.md
https://github.com/dropbox/pyston/blob/master/docs/INSTALLING.md

Créer un environnement

J'ai essayé de créer un environnement en utilisant Vagrant.

$ cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=12.04
DISTRIB_CODENAME=precise
DISTRIB_DESCRIPTION="Ubuntu 12.04 LTS"

Créer un flux

Presque comme documenté.

Obtenez le code pour Pyston

Obtenez le code de github

$ sudo apt-get install git
$ cd ~/
$ git clone https://github.com/dropbox/pyston.git

Installez ce qui dépend de Pyston

$ mkdir ~/pyston_deps

Construire gcc pour clang

$ sudo apt-get install libgmp-dev libmpfr-dev libmpc-dev make build-essential libtool zip gcc-multilib autogen
$ cd ~/pyston_deps
$ wget 'http://www.netgull.com/gcc/releases/gcc-4.8.2/gcc-4.8.2.tar.bz2'
$ tar xvf gcc-4.8.2.tar.bz2
$ mkdir gcc-4.8.2-{build,install}
$ cd gcc-4.8.2-build
$ ../gcc-4.8.2/configure --disable-bootstrap --enable-languages=c,c++ --prefix=$HOME/pyston_deps/gcc-4.8.2-install
$ make -j4
$ make check
$ make install

ccache

$ sudo apt-get install ccache

Ajoutez la ligne suivante à ~ / pyston / src / Makefile.local lorsqu'il n'est pas utilisé

 USE_CCACHE := 0

Présentation des packages requis pour la construction de LLVM

$ sudo apt-get install libncurses5-dev zlib1g-dev

LLVM + clang

$ cd ~/pyston_deps
$ git clone http://llvm.org/git/llvm.git llvm-trunk
$ git clone http://llvm.org/git/clang.git llvm-trunk/tools/clang
$ cd ~/pyston/src
$ make llvm_up
$ make llvm_configure
$ make llvm -j4

libunwind

$ cd ~/pyston_deps
$ wget http://download.savannah.gnu.org/releases/libunwind/libunwind-1.1.tar.gz
$ tar xvf libunwind-1.1.tar.gz
$ mkdir libunwind-1.1-install
$ cd libunwind-1.1
$ ./configure --prefix=$HOME/pyston_deps/libunwind-1.1-install --enable-shared=0
$ make -j4
$ make install
$ ldconfig

valgrind

Selon le document d'installation, apt est ancien, il est donc indiqué que vous devez construire à partir des sources, donc Je vais le mettre de la source docilement.

$ cd ~/pyston_deps
$ wget http://valgrind.org/downloads/valgrind-3.9.0.tar.bz2
$ tar xvf valgrind-3.9.0.tar.bz2
$ mkdir valgrind-3.9.0-install
$ cd valgrind-3.9.0
$ ./configure --prefix=$HOME/pyston_deps/valgrind-3.9.0-install
$ make -j4
$ make install
$ sudo apt-get install libc6-dbg

Puis éditez ~ / pyston / src / Makefile.local

VALGRIND := VALGRIND_LIB=$(HOME)/pyston_deps/valgrind-3.9.0-install/lib/valgrind $(HOME)/pyston_deps/valgrind-3.9.0-install/bin/valgrind

En ce qui concerne les dépendances optionnelles, il est écrit dans Readme.md que vous pouvez l'ignorer, je vais donc l'omettre ici.

(Enfin) Pyston build

$ cd ~/pyston/src
$ make check -j4

Divers tests sont exécutés. Si le test réussit, vous aurez un binaire. Je vous remercie pour votre travail acharné.

$ ls ~/pyston/src/pyston*
/home/vagrant/pyston/src/pyston
/home/vagrant/pyston/src/pyston_prof
/home/vagrant/pyston/src/pyston_dbg

méthode de départ

$ ./pyston
  1.9ms to load stdlib
 4.3ms for initCodegen
4.5ms for jit startup
Pyston v0.1, rev 1fe94923ff6f
>>

Le mode Vervose est standard dans Pyston 0.1, donc à moins que vous ne soyez intéressé par le processus de construction vers LLVM, ajoutez l'option "q (quiet)".

$ ./pyston -q
>>

Lisez le fichier dans REPL avec l'option "i". Au fait, il ne peut être lu que si le fichier est dans ~ / pyston / src (il tombe en raison d'une erreur de segmentation).

$ ./pyston -iq hello.py
Hello Pyston v0.1
Pyston v0.1, rev 1fe94923ff6f
>>

print("Hello Pyston v0.1")

Il peut également être exécuté à partir d'un fichier.

$ ./pyston -q hello.py
Hello Pyston v0.1

Voir ici pour plus de détails.

https://github.com/dropbox/pyston/blob/master/README.md#command-line-options

point important

Gouttes lors de la rupture avec REPL
Actuellement, la bibliothèque est rarement implémentée. Actuellement, seul time.time peut être utilisé.
Presque aucune implémentation autre que la grammaire de base de Python. Les fonctionnalités qui ne sont pas implémentées seront supprimées si elles sont utilisées. https://github.com/dropbox/pyston/blob/master/README.md#v01-422014
Bien sûr, l'inclusion de liste ne fonctionne pas.

Si vous n'avez pas été déçu jusqu'à présent, lisez la suite.

Alors, est-ce vraiment rapide?

Alors, j'ai fait un contrôle de performance. La comparaison est la suivante

Python v2.7.3
PyPy v2.2.1
Pyston v0.1(2014/04/15)

Récursif

import time

def fib(n):
    if n < 2: return n
    return fib(n - 2) + fib(n - 1)

if __name__ == "__main__":
    for x in range(3):
        fib(3)

    start = time.time()
    result = fib(38)
    timespan = time.time() - start
    print(result)
    print (timespan)

Python v2.7.3

$ python -i fib.py
39088169
11.7266070843

PyPy v2.2.1

$ ~/pypy-2.2.1-linux64/bin/pypy -i fib.py
39088169
2.00477910042

Pyston v0.1

$ cd ~/pyston/src
$ ./pyston -iq fib.py
39088169
1.37748503685

Avec ce genre de sentiment, j'ai trouvé qu'il semble que l'on puisse s'attendre à une accélération du code récursif.

boucle

import time

def fib(n):
    value = 0
    f1, f2 = 1, -1
    for i in range(n+1):
        value = f1 + f2
        f2 = f1
        f1 =value

    return value

if __name__ == "__main__":
    for x in range(3):
        fib(3)

    start = time.time()
    result = 0
    for x in range(0,5000):
        result = fib(38)
    timespan = time.time() - start
    print(result)
    print (timespan)