Por que linguagens interpretadas lento?

https://stackoverflow.com/questions/1694402

18-09-2019
|

Pergunta

Eu estava lendo sobre os prós e contras de linguagens interpretadas, e um dos mais contras comuns é a lentidão, mas por que são programas em linguagens interpretadas lento?

Solução

programas nativos ensaios, com instruções escritas para o processador são executados.

Linguagens interpretadas são apenas isso, "interpretado". Alguma outra forma de instrução é lida e interpretada, por um tempo de execução, que por sua vez executa instruções nativas da máquina.

Pense nisso desta maneira. Se você pode falar em sua língua nativa para alguém, que, em geral, trabalhar mais rápido do que ter um intérprete ter de traduzir o idioma em algum outro idioma para o ouvinte a entender.

Note que o que estou descrevendo acima é para quando uma linguagem está sendo executado em um intérprete. Há intérpretes para vários idiomas que há também ligadores nativas para que constroem instruções de máquina nativas. A redução de velocidade (no entanto, o tamanho do que poderia ser) só se aplica ao contexto interpretado.

Assim, é ligeiramente incorreto dizer que o idioma é lenta, mas sim o contexto em que ele está sendo executado que é lento.

C # não é uma linguagem interpretada, mesmo que ele emprega uma linguagem intermediária (IL), este é JITted para instruções nativas antes de ser executado, por isso tem alguns da mesma redução de velocidade, mas não tudo isso, mas eu aposto que se você construiu um intérprete de pleno direito para C # ou C ++, ele seria executado mais lento também.

E só para ficar claro, quando eu digo "lento", que é, naturalmente, um termo relativo.

Outras dicas

Todas as respostas parecem perder o ponto importante real aqui. É a detalhes como "interpretado" código é implementado.

linguagens de script interpretadas são mais lentos porque seu método, objeto e modelo de espaço variável global é dinâmico. Na minha opinião esta é a verdadeira definição de linguagem de script não o fato de que ele é interpretado. Isso requer muitas consultas extras hash tabela em cada acesso a uma chamada de variável ou método. E sua a principal razão pela qual todos eles são terríveis em multithreading e usando um GIL (Global Interpreter Lock). Este pesquisas é onde a maior parte do tempo é gasto. É uma pesquisa de memória aleatória dolorosa, o que realmente dói quando você começa um cache-miss L1 / L2.

Javascript Core8 do Google é tão rápido e focalização quase velocidade C para uma otimização simples: eles tomam o modelo de dados objeto como fixo e criar código interno para acessá-lo como a estrutura de dados de um programa compilado nativo. Quando uma nova variável ou método é adicionado ou removido, em seguida, todo o código compilado é descartado e compilado novamente.

A técnica é bem explicado no jornal Deutsch / Schiffman "implementação eficiente do Smalltalk-80 do sistema".

A pergunta por que PHP, Python e Ruby não está fazendo isso é muito simples de responder:. A técnica é extremamente complicado para implementar

E só o Google tem o dinheiro para pagar o JavaScript porque um interpretador de JavaScript rápido baseado em navegador é a sua necessidade fundamental de seu modelo de negócio de bilhões de dólares.

Pense na interpeter como um emulador para uma máquina que você não acontecer de ter

A resposta curta é que as linguagens compiladas são executados por instruções de máquina enquanto as interpretados são executados por um programa (escrito em uma linguagem compilada) que lê a origem ou um bytecode e, em seguida, essencialmente emula uma máquina hipotética que faria ter executado o programa diretamente se a máquina existia.

Pense no tempo de execução interpretada como um emulador para uma máquina que você não acontecer para realmente ter ao redor no momento.

Esta é, obviamente, complicada pelo JIT (Just In Time) compiladores que Java, C #, e outros têm. Em teoria, eles são tão bons como "AOT" ( "At One Time") compiladores mas na prática esses idiomas ficar mais lento e são prejudicados pela necessidade de ter o compilador em torno de usar a memória e tempo durante a execução do programa. Mas se você diz qualquer um que aqui no SO estar preparado para atrair defensores JIT fanáticos que insistem que não há diferença teórica entre JIT e AOT. Se você perguntar-lhes se Java e C # são tão rápidas como C e C ++, em seguida, eles começam a fazer desculpas e tipo de acalmar um pouco. : -)

Assim, C ++ governa totalmente nos jogos em que a quantidade máxima de computação disponíveis pode sempre ser colocada em uso.

Na área de trabalho e web, tarefas orientada a informação são muitas vezes feito por idiomas, com mais de abstração ou pelo menos a compilação menos, porque os computadores são muito rápidos e os problemas não são computacionalmente intensivas, para que possamos passar algum tempo em metas como time-to-market, a produtividade do programador, ambientes de memória de segurança confiáveis, modularidade dinâmico, e outras ferramentas poderosas.

Esta é uma boa pergunta, mas deve ser formulado um pouco diferente na minha opinião, por exemplo: "Por que são interpretados línguas mais lento do que linguagens compiladas"

Eu acho que é um equívoco comum que linguagens interpretadas são lentos per se. linguagens interpretadas são não lento , mas, dependendo do caso de uso, pode ser mais lento do que a versão compilada. Na maioria dos casos interpretado línguas são realmente rápido o suficiente !

"bastante rápido", além do aumento da produtividade do uso de uma linguagem como Python sobre, por exemplo, C deve ser suficiente justificação para considerar uma linguagem interpretada. Além disso, você sempre pode substituir certas partes do seu programa interpretado com uma implementação C rápido, se você realmente precisa de velocidade. Mas, novamente, medir primeiro e determinar se a velocidade é realmente o problema, em seguida, otimizar.

Curva de 100 vezes, os conteúdos da ansa são interpretados 100 vezes em código de nível baixo.

Não em cache, não reutilizado, não otimizado.

Em termos simples, um compilador interpreta uma vez em código de baixo nível

Editar, depois dos comentários:

JIT é compilado código , não interpretados. É apenas compilado mais tarde não up-front
Refiro-me à definição clássica, não modernas implementações práticas

Além das outras respostas há otimização: quando você está compilando um programa, você geralmente não se importa quanto tempo leva para compilar - o compilador tem muito tempo para otimizar seu código. Quando você está interpretando código, ele tem que ser feito muito rapidamente, então algumas das otimizações mais inteligentes pode não ser capaz de ser feita.

Uma pergunta simples, sem qualquer resposta simples real. A linha inferior é que todos os computadores realmente "entender" é instruções binárias, que é o "fast" linguagens como C são compilados em.

Depois, há máquinas virtuais, que compreendem diferentes instruções binárias (como Java e .NET), mas aqueles que têm de ser traduzidos em tempo real para instruções de máquina por um Just-In-Compiler (JIT). Isso é quase tão rápido (ainda mais rápido em alguns casos específicos, porque o JIT tem mais informação do que um compilador estático sobre como o código está sendo usado.)

línguas Então não são interpretadas, que normalmente também têm as suas próprias instruções binárias intermediárias, mas as funções de intérprete muito parecido com um laço com um grande switch nele com um caso para cada instrução, e como executá-lo. Este nível de abstração sobre o código de máquina subjacente é lento. Há mais instruções envolvidos, longas cadeias de chamadas de função do intérprete para fazer mesmo coisas simples, e pode-se argumentar que a memória cache e não são usados ??de forma tão eficaz como resultado.

Mas linguagens interpretadas são muitas vezes rápido o suficiente para os fins a que se está acostumado. aplicações web são invariavelmente ligado por IO (geralmente o acesso de banco de dados), que é uma ordem de magnitude mais lenta do que qualquer intérprete.

Não existe tal coisa como uma linguagem interpretada. Qualquer idioma pode ser implementado por um intérprete ou um compilador. Estes dias a maioria das línguas têm implementações usando um compilador.

Dito isso, intérpretes são geralmente mais lento, porque eles precisam processar a língua ou algo muito próximo a ele em tempo de execução e traduzi-lo para instruções de máquina. Um compilador faz esta tradução para instruções de máquina apenas uma vez, depois que eles são executados diretamente.

A partir about.com :

uma linguagem interpretada é processado em tempo de execução. Cada linha é lido, analisado e executado. Ter de reprocessar uma linha de cada vez num ciclo é o que faz linguagens interpretadas de modo lento. Este meio de sobrecarga que código é executado interpretados entre 5 - 10 vezes mais lento do que o código compilado. o linguagens interpretadas como Básico ou JavaScript são as mais lentas. Seus vantagem não é a necessidade de estar recompilados depois de mudanças e que é calhar quando você está aprendendo a programa.

Os 5-10 vezes mais lento não é necessariamente verdade para linguagens como Java e C #, no entanto. Eles são interpretados, mas os compiladores just-in-time pode gerar linguagem de máquina instruções para algumas operações, acelerando as coisas de forma dramática (perto da velocidade de uma linguagem compilada às vezes).

Linguagens interpretadas precisa ler e interpretar seu código-fonte em tempo de execução. Com código compilado um monte de que a interpretação é feito antes do tempo (em tempo de compilação).

Muito poucas linguagens de script contemporâneos são "interpretado" nos dias de hoje; Eles são normalmente compilados na mosca, ou em código de máquina ou em alguma linguagem bytecode intermediária, que é (mais eficiente) executado em uma máquina virtual.

Dito isto, eles são mais lentos porque a sua cpu é executar muitos mais instruções por "linha de código", uma vez que muitas das instruções são gastos entender o código em vez de fazer o que a semântica da linha sugerem!

Leia este e contras de linguagens interpretadas

Esta é a idéia relevante nesse post para o seu problema.

Uma execução por um intérprete é geralmente muito menos eficiente, em seguida, execução regular do programa. Acontece porque ou todas as instruções deve passar uma interpretação em tempo de execução ou como na mais recente implementações, o código tem que ser compilado para um intermediário representação antes de cada execução.

Pela mesma razão que é mais lento para falar via tradutor que na língua nativa. Ou, lendo com dicionário. Leva tempo para traduzir.

Update: não, eu não vi que a minha resposta é a mesma que a aceita, a um grau; -)

Sim, linguagens interpretadas são lentos ...

No entanto, considere o seguinte. Eu tinha um problema para resolver. Ele me levou 4 minutos para resolver o problema em Python, e o programa levou 0,15 segundos para ser executado. Então eu tentei escrever em C, e eu tenho um tempo de execução de 0,12 segundos, e ele me levou 1 hora para escrevê-lo. Tudo isso porque a maneira prática de resolver o problema em questão era usar hashtables, eo hashtable dominado o tempo de execução de qualquer maneira.

Wikipedia diz ,

Interpretação código é mais lento do que executar o código compilado porque o intérprete deve analisar cada instrução no programa de cada vez que é executado e, em seguida, executar a ação desejada, enquanto que o código compilado apenas executa a ação dentro de um contexto fixo determinado pela compilação . Esta análise de tempo de execução é conhecido como "sobrecarga interpretativa". O acesso a variáveis ??também mais lento está em um intérprete porque o mapeamento de identificadores para locais de armazenamento deve ser feito repetidamente em tempo de execução em vez de em tempo de compilação.

Consulte este IBM doc ,

programa interpretado deve ser traduzido cada vez que é executado, há uma sobrecarga maior. Assim, uma linguagem interpretada é geralmente mais adequada aos pedidos ad hoc do que pedidos predefinidos.

Em Java que ele é considerado como uma linguagem interpretada, Ele usa JIT (Just-in-Time) compilação que mitigar o problema acima usando uma técnica de armazenamento em cache para armazenar em cache o bytecode compilado.

O compilador JIT lê os bytecodes em muitas seções (ou integralmente, raramente) e compila-los dinamicamente em código de máquina para que o programa pode correr mais rápido. Isso pode ser feito por arquivo, por função ou até mesmo em qualquer fragmento de código arbitrário; o código pode ser compilado quando ele está prestes a ser executado (daí o nome "just-in-time"), e depois em cache e reutilizados mais tarde sem a necessidade de ser recompilados.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow