Pourquoi les langues Interprété lent?

https://stackoverflow.com/questions/1694402

18-09-2019
|

Question

Je suis en train de lire sur les avantages et les inconvénients des langages interprétés, et l'un des inconvénients les plus courantes est la lenteur, mais pourquoi les programmes dans les langues interprétées lent?

La solution

programmes autochtones exécute à l'aide des instructions écrites pour le processeur qu'ils exécutent.

langues Interprété ne sont que, « interprété ». Une autre forme d'instruction est lu et interprété par un moteur d'exécution, ce qui exécute des instructions machine natives.

Pensez-y de cette façon. Si vous pouvez parler dans votre langue maternelle à quelqu'un, qui fonctionnerait généralement plus rapide que d'avoir un interprète ayant de traduire votre langue dans une autre langue pour l'auditeur à comprendre.

Notez que ce que je décris ci-dessus est quand une langue est en cours d'exécution dans un interprète. Il y a des interprètes pour de nombreuses langues qu'il ya aussi des linkers indigènes pour que construire des instructions machine natives. La réduction de la vitesse (mais la taille de ce pourrait être) applique uniquement au contexte interprété.

Alors, il est un peu inexact de dire que le langue est lente, elle est plutôt le contexte dans lequel il est en cours d'exécution qui est lent.

C # est pas un langage interprété, même si elle emploie un langage intermédiaire (IL), cela est JITted aux instructions natives avant d'être exécuté, il a donc certains de la même réduction de la vitesse, mais pas tout cela, mais je serais prêt à parier que si vous avez construit un interprète à part entière pour # C ou C ++, il fonctionne plus lentement aussi.

Et juste pour être clair, quand je dis « lent », qui est bien sûr un terme relatif.

Autres conseils

Toutes les réponses semblent manquer le point important réel ici. Il est le détail comment le code « interprété » est mis en œuvre.

langages de script Interprété sont plus lents parce que leur méthode, objet et modèle global de l'espace variable est dynamique. À mon avis, c'est la définition réelle de la langue de script ne le fait qu'il est interprété. Cela nécessite beaucoup de hachage table de recherches supplémentaires sur chaque accès à un appel variable ou méthode. Et c'est la principale raison pour laquelle ils sont tous terribles à multithreading et en utilisant un GIL (Global Interpreter Lock). C'est là lookups la plupart du temps est passé. Il est une recherche douloureuse mémoire aléatoire, ce qui fait vraiment mal quand vous obtenez un cache-miss L1 / L2.

Javascript Core8 de Google est si rapide et le ciblage presque la vitesse C pour une optimisation simple: ils prennent le modèle de données d'objet comme fixe et créer un code interne pour y accéder comme la structure de données d'un programme compilé natif. Lorsqu'une nouvelle variable ou méthode est ajouté ou enlevé, tout le code compilé est mis au rebut et compilé à nouveau.

La technique est bien expliqué dans le document Deutsch / Schiffman « Mise en œuvre efficace du système Smalltalk-80 ».

La question pourquoi php, Python et Ruby ne sont pas le faire est assez simple à répondre: la technique est extrêmement compliqué à mettre en œuvre

Et que Google a l'argent pour payer JavaScript parce qu'un interpréteur JavaScript basé sur un navigateur rapide est leur besoin fondamental de leur modèle d'affaires d'un milliard de dollars.

Pensez à la interpeter comme un émulateur pour une machine que vous ne disposeriez pas

La réponse courte est que les langages compilés sont exécutés par des instructions de la machine alors que celles interprétées sont exécutées par un programme (écrit dans un langage compilé) qui lit la source ou un bytecode puis émule essentiellement une machine hypothétique que serait ont exécuter le programme directement si la machine existait.

Pensez à l'exécution interprété comme un émulateur pour une machine que vous n'arrive d'avoir fait autour pour le moment.

Ceci est évidemment compliquée par le JIT (Just In Time) compilateurs Java, C #, et d'autres ont. En théorie, ils sont aussi bons que les compilateurs « AOT » ( « à un moment donné »), mais dans la pratique ces langues plus lent et obsolète sont handicapés par besoin d'avoir le compilateur autour de l'utilisation de la mémoire et le temps à l'exécution du programme. Mais si vous dites tout cela ici alors soyez prêt à attirer les défenseurs JIT enragés qui insistent sur le fait qu'il n'y a pas de différence théorique entre JIT et AOT. Si vous leur demandez si Java et C # sont aussi rapides que C et C ++, puis ils commencent à faire des excuses et le genre de calme un peu. : -)

Alors, C ++ totalement des règles dans les jeux où le montant maximum disponible de calcul peut toujours être mis à utiliser.

Sur le bureau et le Web, les tâches liées à l'information sont souvent fait par des langues avec plus abstraction ou au moins moins compilation, parce que les ordinateurs sont très rapides et les problèmes ne sont pas de calculs, nous pouvons donc passer un peu de temps sur des objectifs tels que temps sur le marché, la productivité des programmeurs, fiables environnements de sécurité mémoire, modularité dynamique, et d'autres outils puissants.

Ceci est une bonne question, mais devrait être formulée un peu différent, à mon avis, par exemple: « Pourquoi les langues interprétées plus lent que les langages compilés »

Je pense qu'il est une idée fausse que les langues interprétées sont lentes en soi. langues sont Interprété ne ralentirait pas , mais, selon le cas d'utilisation, pourrait être plus lent que la version compilée. Dans la plupart des cas langues interprétées sont en fait assez vite

« assez rapide », plus l'augmentation de la productivité de l'utilisation d'un langage comme Python sur, par exemple, C devrait être une justification suffisante pour considérer un langage interprété. En outre, vous pouvez toujours remplacer certaines parties de votre programme interprété avec une implémentation C rapide, si vous avez vraiment besoin de vitesse. Mais là encore, mesurer d'abord et déterminer si la vitesse est vraiment le problème, optimiser.

Boucle 100 fois, le contenu de la boucle sont interprétées 100 fois en code de bas niveau.

Non mis en cache, et non réutilisé, non optimisé.

En termes simples, un compilateur interprète une fois en code de bas niveau

Modifier, après les commentaires:

JIT est compilé Code , non interprété. Il est juste compilé plus tard pas à l'avant
Je me réfère à la définition classique, et non mises en œuvre pratiques modernes

En plus des autres réponses il y a optimisation: lorsque vous compilez un programme, vous ne prend soin habituellement pas combien de temps pour compiler - le compilateur a beaucoup de temps pour optimiser votre code. Lorsque vous interpréter le code, il doit être fait très rapidement si quelques-unes des optimisations plus intelligentes pourraient ne pas être en mesure de faire.

Une simple question, sans réponse simple réelle. L'essentiel est que tous les ordinateurs vraiment « comprendre » est des instructions binaires, ce qui est ce que les langages « rapides » comme C sont compilés dans.

Ensuite, il y a des machines virtuelles qui comprendre différentes instructions binaires (comme Java et .NET), mais celles-ci doivent être traduits à la volée aux instructions de la machine par un Just-In-compilateur (JIT). C'est presque aussi rapide (encore plus rapide dans certains cas particuliers, car le JIT a plus d'informations qu'un compilateur statique sur la façon dont le code est utilisé.)

Ensuite, il y a des langages interprétés, qui ont généralement leurs propres instructions binaires intermédiaires, mais les fonctions d'interprète un peu comme une boucle avec une instruction grand interrupteur avec un cas pour chaque instruction, et comment l'exécuter. Ce niveau d'abstraction sur le code de la machine sous-jacente est lente. Il y a plus d'instructions impliquées, de longues chaînes d'appels de fonctions dans l'interpréteur de faire même des choses simples, et il peut faire valoir que la mémoire cache et ne sont pas utilisés de manière aussi efficace en conséquence.

Mais les langues sont souvent interprétées assez rapide pour les fins pour lesquelles ils sont utilisés. Les applications Web sont invariablement liés par IO (généralement d'accès de base de données) qui est un ordre de grandeur plus lent que tout interprète.

Il n'y a pas une telle chose comme un langage interprété. Toute langue peut être mis en œuvre par un interprète ou d'un compilateur. Ces jours-ci la plupart des langues ont mises en œuvre en utilisant un compilateur.

Cela dit, les interprètes sont généralement plus lents, parce qu'ils ont besoin de traiter la langue ou quelque chose d'assez près au moment de l'exécution et traduit les instructions de la machine. Un compilateur fait cette traduction aux instructions de la machine une seule fois, après quoi ils sont exécutés directement.

De about.com :

un langage interprété est traité lors de l'exécution. Chaque ligne est lue, analysé et exécuté. Avoir à retraiter une ligne à chaque fois dans une boucle est ce qui rend les langages interprétés donc lent. Cette surcharge signifie que code interprété court entre 5 - 10 fois plus lent que le code compilé. le langues comme base ou interprétées JavaScript sont les plus lents. Leur avantage n'est pas besoin d'être recompiler après les changements et est à portée de main lorsque vous apprenez à programmer.

Les 5-10 fois plus lent est pas nécessairement vrai pour les langages comme Java et C #, cependant. Ils sont interprétés, mais le compilateurs juste à temps peut générer le langage machine instructions pour certaines opérations, ce qui accélère les choses de façon spectaculaire (près de la vitesse d'un langage compilé parfois).

langues Interprété doivent lire et interpréter votre code source au moment de l'exécution. Avec le code compilé beaucoup de cette interprétation est faite à l'avance (à la compilation).

Très peu de langages de script contemporains sont "interprétés" ces jours-ci; ils sont généralement compilés à la volée, soit en code machine ou dans un langage de bytecode intermédiaire, qui est (plus efficace) exécuté dans une machine virtuelle.

Cela dit, elles sont plus lentes parce que votre cpu exécute beaucoup plus d'instructions par « ligne de code », puisque la plupart des instructions sont consacrées à la compréhension du code plutôt que de faire ce qui suggère la sémantique de la ligne!

Lire cette et inconvénients des langues Interprété

Ceci est l'idée pertinente dans ce poste à votre problème.

Une exécution par un interprète généralement beaucoup moins efficace alors régulière exécution du programme. Ça arrive parce que chaque instruction soit devrait passer une interprétation à exécution ou dans les nouveaux mises en œuvre, le code doit être compilé en un intermédiaire représentation avant chaque exécution.

Pour la même raison qu'il est plus lent à parler par traducteur que dans la langue maternelle. Ou, la lecture avec le dictionnaire. Il faut du temps pour traduire.

Mise à jour: non, je ne vois pas que ma réponse est la même que celle acceptée, à un degré; -)

Oui, les langues sont interprétées lent ...

Cependant, considérer ce qui suit. J'ai eu un problème à résoudre. Il m'a fallu 4 minutes pour résoudre le problème en Python, et le programme a pris 0,15 secondes pour courir. Alors j'ai essayé de l'écrire en C, et je suis une durée d'exécution de 0,12 secondes, et il m'a fallu 1 heure pour l'écrire. Tout cela parce que le moyen pratique de résoudre le problème en question était d'utiliser hashage et le Hashtable a dominé le temps d'exécution de toute façon.

Wikipedia dit ,

Code interprétation est plus lent que l'exécution du code compilé parce que le interprète doit analyser chaque énoncé dans le programme chaque fois qu'il est exécuté, puis effectuer l'action souhaitée, alors que le code compilé effectue simplement l'action dans un contexte fixe déterminé par la compilation . Cette analyse d'exécution est connu comme « frais généraux d'interprétation ». L'accès aux variables est aussi plus lente dans un interprète car le mappage d'identificateurs à des emplacements de stockage doit être effectué à plusieurs reprises lors de l'exécution plutôt qu'au moment de la compilation.

IBM doc ,

programme Interprété doit être traduit à chaque fois qu'il est exécuté, il y a un surcoût supérieur. Ainsi, un langage interprété est généralement plus adaptée aux demandes ad hoc que les demandes prédéfinies.

En Java mais il est considéré comme un langage interprété, il utilise JIT (Just-in-Time) compilation qui allègent la question ci-dessus en utilisant une technique de mise en cache pour mettre en cache le bytecode compilé.

Le compilateur JIT lit le bytecode dans de nombreuses sections (ou en totalité, rarement) et les compile dynamiquement dans le code de la machine afin que le programme peut courir plus vite. Cela peut être fait par fichier, par fonction ou même sur un fragment de code arbitraire; le code peut être compilé quand il est sur le point d'être exécuté (d'où le nom « juste à temps »), puis mis en mémoire cache et réutilisé plus tard, sans avoir à être recompilés.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow