Pourquoi Python et Ruby si lent, tout en Lisp implémentations rapides?

Je trouve que les choses simples comme les appels de fonction et de boucles, et même des boucles tout en incrémentant un compteur de prendre loin plus de temps en Python et Ruby que le Poulet Régime, de la Raquette, ou SBCL.

Pourquoi est-ce donc? J'entends souvent les gens dire que la lenteur est un prix à payer pour les langages dynamiques, mais Lisps sont très dynamiques et ne sont pas ridiculement lent (ils sont généralement moins de 5 fois plus lent que le C; Ruby et Python peut aller dans les deux chiffres). En outre, Lisp style utilise la récursivité, et pas toujours de la queue de la récursivité, beaucoup, la pile est une liste liée de continuations dans le tas, etc, qui semblent être des choses qui devraient faire Lisp plus lent que l'impératif de style Python et Ruby.

De raquette et de SBCL sont JITted, mais le Poulet Schéma est soit compilé statiquement, ou utilise une non-optimisation de l'interprète, qui doit être mal adaptée à la dynamique des langues et lent. Pourtant, même à l'aide de la naïveté csi interprète pour le Poulet Régime (qui n'a même pas de faire du bytecode à la compilation!), Je reçois des vitesses bien au-delà de Python et Ruby.

Pourquoi, justement, Python et Ruby si ridiculement lent par rapport à la même dynamique Lisps? Est-ce parce qu'ils sont orienté objet et un besoin énorme vtables et type de hiérarchies?

Exemple: fonction factorielle. Python:

def factorial(n):
    if n == 0:
        return 1
    else:
    return n*factorial(n-1)

for x in xrange(10000000):
    i = factorial(10)

Raquette:

#lang racket

(define (factorial n)
  (cond
   [(zero? n) 1]
   [else (* n (factorial (sub1 n)))]))

(define q 0)

(for ([i 10000000])
  (set! q (factorial 10)))

Calendrier résultats:

ithisa@miyasa /scratch> time racket factorial.rkt
racket factorial.rkt  1.00s user 0.03s system 99% cpu 1.032 total
ithisa@miyasa /scratch> time python factorial.py
python factorial.py  13.66s user 0.01s system 100% cpu 13.653 total

SBCL ne pas utiliser un JIT. Il est strictement AOT.
SBCL a un REPL interprète...moi la common lisp n00b toujours été utilisée comme un interprète...
SBCL utilise un compilateur. Toujours et partout. Dans le REPL aussi. SBCL ne pas utiliser les services d'un interprète, par défaut. Chaque expression entrée dans le REPL sera compilé avant son exécution.
Oui, donc le REPL est techniquement un compilateur JIT...
pas de. Le REPL appelle juste la fonction EVAL, qui appelle le code natif compilateur. Le code est entièrement compilé à partir du code source en code natif AVANT l'exécution. C'est juste un différentiel, compilateur, qui permet de compiler des expressions individuelles. Il n'y a pas de code octet de compilation, pas de byte code en code natif compilation JIT, pas d'analyse de l'exécution, pas de cache de code, ... C'est un différentiels code natif compilateur.
Parce que les gens ont passé 55 ans, fait Lisp rapide, mais seulement 20,5 années de prise de Ruby rapide. Et parce que les gens ont dépensé des millions de dollars de prise de Lisp rapide.
Lisps ne sont pas de cette dynamique, en comparaison avec le canard de type de langages à objets.
En quoi est-Lisp "non dynamique"?
Lisp ne dépendent pas de la dynamique de la méthode d'expédition. Il a quelques fonctions polymorphes (notoirement, numérique de la tour), mais la majorité d'appel cibles sont decidable dans le temps de compilation, contrairement à des langages comme Python, où chaque appel a décidé dans l'exécution.
L'indice de référence ne fait pas justice à une main-d'python de l'utilisateur de la sortie. Ils utilisent pypy, numba, ou cython si le code n'était pas assez rapide. J'ai eu 18 secondes pour que le code donc regardé cython dans mon jupyter ordinateur portable. Une version naïve accéléré jusqu'à environ 4 fois à 5 secondes. Une version plus sophistiquée de l'application réduit à 0,33 secondes, plus rapide que le lisp et souvent proche de C. nbviewer.jupyter.org/github/john9631/Jupyter-Notebooks/blob/...

InformationsquelleAutor ithisa | 2013-11-09

17

Compilé Lisp systèmes sont généralement un peu plus rapide que Ruby ou Python.

Voir, par exemple, une comparaison de Rubis et de SBCL:

http://benchmarksgame.alioth.debian.org/u32/benchmark.php?test=all&lang=yarv&lang2=sbcl&data=u32

ou Python et SBCL:

http://benchmarksgame.alioth.debian.org/u32/benchmark.php?test=all&lang=python3&lang2=sbcl&data=u32

Mais gardez à l'esprit les points suivants:
- SBCL utilise un code natif compilateur. Il ne pas utiliser un octet de code de la machine ou de quelque chose comme un compilateur JIT à partir de l'octet de code en code natif. SBCL compile l'ensemble du code à partir du code source en code natif, avant l'exécution. Le compilateur est progressive et permet de compiler des expressions individuelles. Ainsi, il est également utilisé par la fonction EVAL et de la Lecture-Eval-Print-Boucle.
- SBCL utilise un compilateur d'optimisation, ce qui rend l'utilisation de déclarations de type et de l'inférence de type. Le compilateur génère du code natif.
- Common Lisp permet diverses optimisations qui rend le code moins dynamique ou non de la dynamique (l'in-lining, au début de liaison, pas de vérifications de type, code spécialisés déclarée types, la queue-appel optimisations, ...). Code qui rend l'utilisation de ces fonctionnalités avancées peuvent sembler compliqué, surtout si le compilateur a besoin d'être dit à propos de ces choses.
- Sans ces optimisations compilé code Lisp est encore plus rapide que le code interprété, mais plus lent que d'optimisé le code compilé.
- Common Lisp fournit CLOS, le Common Lisp Object System. CLOS de code est généralement plus lent que les non-CLOS où cette comparaison a du sens. Une dynamique fonctionnelle de la langue tend à être plus rapide qu'une dynamique langage orienté objet.
- Si un langage de mise en œuvre utilise un hautement optimisé l'exécution, par exemple pour bignum opérations arithmétiques, un ralentissement de la langue mise en œuvre peut être plus rapide qu'une optimisation du compilateur. Certaines langues ont de nombreux complexes primitives mises en œuvre dans C. Ceux ont tendance à être rapide, tandis que le reste de la langue peut être très lent.
Également certaines opérations peuvent sembler similaires, mais pourrait être différent. Est un for boucle d'itération sur une variable de type entier vraiment la même chose qu'un for boucle qui itère sur une plage?
- Compilé Lisp est plus rapide que interprétée Python. De même, compilé Python (Cython) est plus rapide que interprétée Disponible. Comme indiqué dans le premier post, à l'aide de Cython la fib code de 0,33 secondes au lieu de 18 secondes pour 10 000 000 d'itérations (sur ma machine).
- Python est effectivement compilé: docs.python.org/devguide/compiler.html
InformationsquelleAutor Rainer Joswig
12

Méthode de répartition en Ruby/Python/etc est cher, et Ruby/Python/etc programmes de calcul principalement par des appels de méthodes. Même for boucles en Ruby sont juste sucre syntaxique pour un appel de méthode à each.

InformationsquelleAutor Alex D
2

Je ne sais pas à propos de votre raquette de l'installation, mais la Raquette je viens de apt-get install'd utilise la compilation JIT s'exécuter sans drapeaux. En cours d'exécution avec --no-jit donne un temps beaucoup plus proche de l'Python temps (racket: 3s, racket --no-jit: 37s, python: 74s). Aussi, la cession à portée de module est plus lente que la programmation locale en Python pour la langue des raisons de conception (très libéral module de système), de déplacer le code dans une fonction met Python à des années 60. L'écart restant peut probablement être expliqué comme une combinaison de hasard, optimisation différente focus (appels de fonction doivent être fou rapide en Lisp, Python soin de personnes de moins), la qualité de la mise en œuvre (réf comptage rapport à la bonne GC, pile VM rapport à inscrire VM), etc. plutôt qu'une conséquence fondamentale de la langue dessins.
- Hmm. Pourquoi le JIT fait une telle grande différence? Dans la plupart de mes programmes --no-jit n'ont pas de différence; si, certes, la majorité sont des I/O bound.
- "la valeur globale des objets de vue" est faux ici, étant donné que le code n'a pas de queue appels.
- Je ne sais pas comment vaste appel de manipulation de la pile est disponible dans la Raquette, mais Python objets d'image contiennent un tas de trucs et sont maintenus tout le temps alors que le code est en cours d'exécution. C'est une des raisons les appels de fonction sont relativement lentes.
- Je ne sais pas, je sais que ni les programmes, ni de l'intérieur de la Raquette de JIT. Pour ma part, je me demande pourquoi le JIT ne pas faire une grande différence dans le votre tous les programmes: Un bien mis en œuvre compilateur JIT doit améliorer les performances de façon significative pour la plupart des code.
- Raquette de pile d'images comportent des trucs aussi, encore plus, vous pouvez mettre votre propre défini par l'utilisateur d'informations sur elle; dans tous les cas, la pile dans ce cas, a seulement 10 images, de sorte que la différence n'est pas grande. En outre, une partie de la différence est due à la conception des décisions: permettre arbitraire returns de fonctions et vous avez besoin pour décorer la fonction de trames que le point de retour, etc. Si ces "caractéristiques" sont en vaut le coût ou pas, c'est subjectif débat.
- Vous avez un point, j'ai retiré la partie sur les cadres. Mais que la pile est à seulement 10 images en grand n'est pas important. Il y a beaucoup de fonction appelle à l'OP du code, et les appels de fonction sont optimisés beaucoup dans Lisps (forcément), alors que leur performance en Python n'est pas considéré comme tout aussi important. Les cadres sont un mauvais exemple pour cela, la complexité de la danse à l'interprète de a à faire pour correspondre à des arguments et des mots clés les arguments de la fonction des paramètres nommés, varargs, et **kwds est plus probablement à l'origine de la lenteur.
- Ouais, ce genre de choses sont susceptibles d'être une beaucoup plus grande partie du coût, mais vous devriez également considérer que la Raquette a tous ces gadgets trop. Une autre source de coût est de savoir si vous utilisez uniquement des méthodes et donc de payer le prix de l'envoi à chaque appel. Lorsque vous utilisez une CL, par exemple, vous pouvez voir significative les performances si vous le commutateur de fonctions de fonctions génériques.
InformationsquelleAutor
-4

Je pense que plutôt que de Python est lent lui-même, qu'il est l'interpréteur Python se déplaçant à travers le code à un rythme plus lent. Si vous avez essayé de compiler le code avec un outil tel que py2exe alors il peut être plus rapide que lisp. Vous devriez essayer, mais je pense qu'il a une lente interprète.
- Python est défini par le Disponible interprète bien.
- Aussi, j'ai essayé pypy mais il optimise l'ensemble de la boucle de suite parce qu'il n'est pas visible effets secondaires.
- ensuite, essayez q += factorial(10) et print q à la fin
- Je doute fort que py2exe permettra d'éliminer la différence. L'interprétation de frais généraux est mesurable, mais loin d'être énorme, et un interpréteur Lisp aurait également l'interprétation des frais généraux (bien que la valeur exacte serait bien différent). En fait, je ne pense pas que py2exe supprime l'interprétation à tous, c'est juste bundles votre code Python et le Disponible de code avec du code C qui fait l'équivalent de exec(open(module).read()). Essayez Cython ou Nuitka au lieu de mesurer l'interprétation des frais généraux, ceux compiler Python(-ish) code C des appels d'API.
InformationsquelleAutor Jake Zachariah Nixon

Vous devez vous connecter pour publier un commentaire.