Quelle est la relation entre les interprètes méta-circulaires, les machines virtuelles et l'augmentation des performances?

12

J'ai lu sur les interprètes méta-circulaires sur le web (y compris SICP) et j'ai examiné le code de certaines implémentations (comme PyPy et Narcissus).

J'ai lu pas mal de choses sur deux langues qui ont fait grand usage de l'évaluation métacirculaire, Lisp et Smalltalk. Pour autant que je sache, Lisp était le premier compilateur auto-hébergé et Smalltalk avait la première "vraie" implémentation JIT.

Une chose que je n'ai pas bien comprise est comment ces interprètes / compilateurs peuvent-ils atteindre de si bonnes performances ou, en d'autres termes, pourquoi PyPy est-il plus rapide que CPython? Est-ce à cause de la réflexion?

Et aussi, mes recherches Smalltalk m'ont amené à croire qu'il existe une relation entre JIT, machines virtuelles et réflexion. Les machines virtuelles telles que la JVM et le CLR permettent une grande introspection de type et je crois qu'elles en font un grand usage dans la compilation Just-in-Time (et AOT, je suppose?). Mais pour autant que je sache, les machines virtuelles sont un peu comme des CPU, en ce sens qu'elles ont un jeu d'instructions de base. Les machines virtuelles sont-elles efficaces car elles incluent des informations de type et de référence, ce qui permettrait une réflexion indépendante du langage?

Je pose cette question car de nombreux langages interprétés et compilés utilisent désormais le bytecode comme cible (LLVM, Parrot, YARV, CPython) et les machines virtuelles traditionnelles comme JVM et CLR ont gagné en performances incroyables. On m'a dit qu'il s'agissait de JIT, mais pour autant que je sache, JIT n'a rien de nouveau depuis que Smalltalk et le propre Self de Sun l'ont fait avant Java. Je ne me souviens pas que les machines virtuelles aient particulièrement bien performé dans le passé, il n'y en avait pas beaucoup en dehors de JVM et .NET et leurs performances n'étaient certainement pas aussi bonnes qu'aujourd'hui (j'aurais aimé pouvoir trouver cette affirmation mais je parler d'expérience personnelle).

Puis tout d'un coup, à la fin des années 2000, quelque chose a changé et de nombreuses machines virtuelles ont commencé à apparaître, même pour les langues établies, et avec de très bonnes performances. A-t-on découvert quelque chose sur l'implémentation JIT qui a permis à presque toutes les machines virtuelles modernes de monter en flèche en termes de performances? Un papier ou un livre peut-être?

virtual-machine reflection jit smalltalk Gomi
la source
3
Argent. L'argent qui était auparavant versé dans C ++ et Fortran est désormais versé dans HotSpot, CLR, Mono, V8, Nitro, SpiderMonkey, etc.
Jörg W Mittag
Je ne peux que deviner, mais je pense que c'est juste une amélioration au fil du temps, comme décrit ici joelonsoftware.com/articles/fog0000000017.html
Doc Brown
1
RE comment PyPy peut être plus rapide que CPython: il n'est pas écrit en Python, il est écrit dans un langage assez différent qui peut être optimisé AOT efficacement .
1
@Gomi Il ne s'agit pas de savoir à quel point le langage d'implémentation est similaire au langage implémenté. Il existe des interprètes JavaScript, Lisp, Prolog, SmallTalk et Ruby écrits en RPython et ils obtiennent exactement les mêmes avantages que PyPy. La seule raison pour laquelle RPython est basé sur Python est qu'il a été créé par un tas de passionnés de Python. Les fonctionnalités de RPython qui rendent PyPy rapide n'ont rien à voir avec Python: génération automatique de compilateur JIT, les garbage collector, etc. - et oui, la plupart de cela pourrait en principe se faire en utilisant d'autres langages. Vous devez cependant créer un tout nouveau compilateur.
4
-1 parce que vous semblez avoir au moins 3 questions différentes ici: (a) Pourquoi les implémentations méta-circulaires sont-elles si bonnes? (b) Les machines virtuelles sont-elles efficaces en raison des informations de type et l'introspection est-elle bénéfique pour les performances? (c) Comment se fait-il que la popularité des VM ait augmenté à la fin des années 2000, et comment se fait-il qu'elles aient soudainement de bonnes performances? Je pense qu'il vaut mieux poser ces questions séparément.
Oak

Réponses:

1

2 sur 3: Il n'y a pas de relation entre les exécutions de langage "méta-circulaire" et "hautes performances". Les exécutions méta-circulaires qui atteignent des performances élevées le font en compilant JIT en code natif et en exécutant le code natif. Il n'y a aucune raison pour que votre runtime Python haute performance doive être écrit en Python, ou Lisp en Lisp, etc. Mais si vous pensez que votre langage est plus puissant, expressif, etc. que les autres, pourquoi ne pas l'utiliser pour écrire son propre runtime? Ou si vous ne pensez pas que votre langue est en quelque sorte "meilleure" que les autres, pourquoi allez-vous avoir la peine de la mettre en œuvre?

Alex D
la source