introduction

"Il évolue beaucoup" ou quelque chose que vous écrivez bien. J'ai été impressionné par les nouvelles ci-dessous, alors j'ai décidé d'essayer Grumpy (Go running Python). My Navi News: Google développe un environnement d'exécution Python très évolué avec Go

Lisez le blog original.

Je pense que le blog original a été extrait pour créer la rubrique "Très grande échelle", alors lisons également le blog original (ancien blog) en diagonale. ..

https://opensource.googleblog.com/2017/01/grumpy-go-running-python.html

À propos de l'évolutivité élevée dans le benchmark Fib

Description 《Very Scale》: «Grumpy» est encore au stade expérimental, mais il est hautement évolutif dans le benchmark Fib par rapport à CPython.

=> Description sur le blog d'origine.

In particular, Grumpy has no global interpreter lock, and it leverages Go’s garbage collection for object lifetime management instead of counting references. We think Grumpy has the potential to scale more gracefully than CPython for many real world workloads. Results from Grumpy’s synthetic Fibonacci benchmark demonstrate some of this potential:

Pour Global Interpreter Lock (GIL), voir [Japanese wikipedia](https://ja.wikipedia.org/wiki/%E3%82%B0%E3%83%AD%E3%83%BC% E3% 83% 90% E3% 83% AB% E3% 82% A4% E3% 83% B3% E3% 82% BF% E3% 83% 97% E3% 83% AA% E3% 82% BF% E3% 83% AD% E3% 83% 83% E3% 82% AF) est également facile à comprendre. La combinaison de Python et de code C non thread-safe signifie que le verrouillage par processus limite l'évolutivité. Les résultats de référence publiés dans le blog original sont les suivants.

Grumpy est plus lent pour les threads simples, mais vous pouvez voir que la puissance de traitement évolue linéairement pour les threads multiples. Cependant, ce résultat est dû à l'arrêt du support des modules d'extension Python et C.

(Blog original) Tout d'abord, nous avons décidé de renoncer à la prise en charge des modules d'extension C. Cela signifie que Grumpy ne peut pas tirer parti de la richesse des extensions Python C existantes, mais cela nous a donné beaucoup de flexibilité pour concevoir une API et une représentation d'objets qui s'adaptent aux charges de travail parallèles ..

À propos de l'écosystème Grumpy

Je pensais que la description suivante était assez trompeuse, alors vérifions la situation réelle.

Description en << Very Scale >>: Go a été initialement développé dans le but d'obtenir des performances élevées en traitement parallèle, et est bon pour le traitement parallèle. Il semble que Grumpy a encore besoin de temps de développement en termes de compatibilité, mais Grumpy, qui démontre des performances élevées en multi-core / processeur, pourrait être utilisé comme un environnement d'exécution Python très important à l'avenir.

Ancien blog =>

Second, Grumpy is not an interpreter. Grumpy programs are compiled and linked just like any other Go program. ... the biggest advantage is that interoperability with Go code becomes very powerful and straightforward: Grumpy programs can import Go packages just like Python modules! (Je dis): Les programmes grincheux générés à partir de Python sont compilés et liés comme n'importe quel autre programme Go ... Le plus grand avantage de ceci est l'interopérabilité avec Go. Les programmes grincheux peuvent importer des packages Go comme les modules Python.

Grumpy n'avait probablement pas l'intention d'exécuter du code python existant sur Go lorsqu'il a renoncé à appeler du code C. Je pense que le développement futur autour de Grumpy ne sera pas dans le sens d'exécuter des frameworks Python existants tels que Django, mais dans le sens de faciliter la combinaison des bibliothèques Go et du code Python.

Essayez d'exécuter Grumpy.

Je voulais savoir quel code Grumpy crache, alors j'ai essayé de lancer Grumpy. Le code original ressemble à ceci.

`benchmark1.py`


#-*- using:utf-8 -*-
import time
if __name__ == '__main__':
    start = time.time()
    for i in range(1,50):
        print (i, 100.0 / (i * i * i ))
    elapsed_time = time.time() - start
    print ("------- result ------")
    print (elapsed_time * 1000 , "ms")

Le temps d'exécution en Cpython est d'environ 1,3 ms.

$ python benchmark1.py (1, 100.0) (2, 12.5) .. (Omis) .. (49, 0.0008499859752314087) ------- result ------ (1.3232231140136719, 'ms')

Présentez Grumpy. Pour Linux (ubuntu16.04) avec Go, python et gcc, il était facile de déployer comme indiqué par le site github.

git clone https://github.com/google/grumpy cd grumpy make export GOPATH=PWD/build export PYTHONPATH=PWD/build/lib/python2.7/site-packages tools/grumpc benchmark1.py > benchmark1.go go build benchmark1.go

Essayez d'exécuter le binaire benchmark1 créé à partir de benchmark1.go.

$ ./benchmark1 (1, 100) (2, 12.5) .. (Omis) .. (49, 0.0008499859752314087) ------- result ------ (5.621671676635742, 'ms')

... comme prévu, cela prend plus de temps que Cpython.

Le code source de Go généré par Grumpy est long, je vais donc le mettre ci-dessous. À ce stade, cela ne semble pas être quelque chose que les humains devraient lire. ..

https://gist.github.com/kmry/906a8154a37bb0060d35eee20a3e06ca

Si tu es intéressé ...

Si vous êtes intéressé par le code python sur Go by grumpy, je pense que c'est une bonne idée de regarder d'abord le code sur github. L'implémentation Go compatible avec la bibliothèque standard python est également avancée dans une certaine mesure.

Par exemple, si vous regardez le module de temps utilisé pour mesurer le temps d'exécution ci-dessus, https://github.com/google/grumpy/search?q=time

Vous pouvez voir que l'implémentation est encapsulée dans la bibliothèque standard de Go, comme indiqué ci-dessous.

`grumpy/lib/time.py`


"""Time access and conversions."""

from __go__.time import Now, Second, Sleep  # pylint: disable=g-multiple-import


def sleep(secs):
  Sleep(secs * Second)


def time():
  return float(Now().UnixNano()) / Second

Si une "personne wow" apparaît comme une extension de ces efforts, un framework compatible WAF pour Python peut apparaître sur grumpys. # Non garanti :)

Une fois qu'un peu plus d'informations sont disponibles, il peut être amusant d'écrire un traitement parallèle en utilisant la bibliothèque go en python.

J'ai essayé Grumpy (allez exécuter Python).