Perché sono interpretati Lingue lento?

https://stackoverflow.com/questions/1694402

18-09-2019
|

Domanda

ho letto circa i pro ei contro di linguaggi interpretati, e uno degli svantaggi più comuni è la lentezza, ma perché sono programmi in linguaggi interpretati lenta?

Soluzione

programmi nativi viene eseguito utilizzando istruzioni scritte per il processore su cui girano.

I linguaggi interpretati sono proprio questo, "interpretato". Qualche altra forma di istruzione viene letta e interpretata, da un tempo di esecuzione, che a sua volta esegue istruzioni macchina native.

Pensare in questo modo. Se si può parlare nella vostra lingua madre a qualcuno, che avrebbe in generale lavorare più velocemente di avere un interprete dover tradurre la lingua in un'altra lingua per l'ascoltatore a capire.

Si noti che quello che sto descrivendo sopra è per quando una lingua è in esecuzione in un interprete. Ci sono interpreti per molte lingue che c'è anche linker native per questo costruire istruzioni macchina native. La riduzione della velocità (tuttavia la dimensione di tale sia) si applica solo al contesto interpretato.

Quindi, è un po 'corretto dire che il lingua è lento, ma è il contesto in cui è in esecuzione che è lento.

C # non è un linguaggio interpretato, anche se si utilizza un linguaggio intermedio (IL), questo è JITted alle istruzioni native prima di essere giustiziato, quindi ha alcuni della stessa riduzione di velocità, ma non tutto questo, ma io scommetto che se hai costruito un interprete a pieno titolo per C # o C ++, sarebbe correre più lento pure.

E tanto per essere chiari, quando dico "lento", che è, naturalmente, un termine relativo.

Altri suggerimenti

Tutte le risposte sembrano perdere il vero punto importante qui. E 'il dettaglio come codice "interpretato" è implementata.

linguaggi di script interpretato sono più lenti, perché il loro metodo, oggetto e spazio modello variabile globale è dinamica. A mio parere questa è la vera definizione di del linguaggio di script non il fatto che viene interpretato. Ciò richiede molte ricerche in più di hash-table su ogni accesso a una chiamata variabile o metodo. E la sua la ragione principale per cui sono tutti terribile a multithreading e utilizzando un GIL (Global Interpreter Lock). Questo ricerche è dove la maggior parte del tempo viene speso. Si tratta di una dolorosa ricerca di memoria casuale, che fa veramente male quando si ottiene un L1 / L2 di cache-miss.

Google JavaScript Core8 è così veloce e il targeting quasi la velocità C per una semplice ottimizzazione: prendono il modello di dati oggetto come fisso e creare codice interno di accedervi come la struttura dei dati di un programma compilato nativo. Quando viene aggiunto o rimosso poi una nuova variabile o un metodo tutto il codice compilato viene scartato e compilato nuovamente.

La tecnica è ben spiegato nel documento Deutsch / Schiffman "Attuazione efficace del sistema Smalltalk-80".

La domanda sul perché php, Python e Ruby non stanno facendo questo è abbastanza semplice rispondere: la tecnica è estremamente complicato da implementare

E solo Google ha i soldi per pagare JavaScript perché un veloce basata su browser interprete JavaScript è il loro bisogno fondamentale del loro modello di business miliardi di dollari.

Pensate al interpeter come un emulatore per una macchina che non capita di avere

La risposta breve è che i linguaggi compilati vengono eseguiti da istruzioni macchina mentre quelli interpretati sono eseguite da un programma (scritto in un linguaggio compilato) che legge sia la fonte o un bytecode e poi emula essenzialmente una macchina ipotetica che em < > farebbe hanno eseguito il programma direttamente se la macchina esistesse.

Si pensi al runtime interpretato come un emulatore per una macchina che non capita di avere intorno in realtà in questo momento.

Questa è ovviamente complicata dal JIT (Just In Time) compilatori che Java, C #, e gli altri hanno. In teoria, sono altrettanto buone come compilatori "AOT" ( "Un tempo"), ma, in pratica, quelle lingue più lenti e sono penalizzati dalla necessità di avere il compilatore intorno usando la memoria e il tempo durante l'esecuzione del programma. Ma se dici niente di tutto questo qui in modo da essere pronti per attirare i difensori JIT rabbiosi che insistono sul fatto che non esiste alcuna differenza teorica fra JIT e AOT. Se si chiede loro se Java e C # sono veloci come C e C ++, poi iniziano a fare scuse e il tipo di calmarsi un po '. : -)

Quindi, C ++ totalmente norme in giochi in cui la quantità massima di calcolo a disposizione può sempre essere messo in uso.

Sul desktop e web, attività di informazione-oriented sono spesso fatto da lingue con maggiore astrazione o almeno meno compilazione, perché i computer sono molto veloci ed i problemi non sono computazionalmente intensive, così possiamo passare un po 'di tempo su obiettivi come il time-to-market, la produttività dei programmatori, gli ambienti di memoria di sicurezza affidabili, modularità dinamica, e altri potenti strumenti.

Questa è una buona domanda, ma dovrebbe essere formulato un po 'diverso, a mio parere, ad esempio: "Perché lingue vengono interpretati più lenti rispetto ai linguaggi compilati"

Credo che sia un malinteso comune che interpretati lingue sono lenti per sé. linguaggi interpretati sono non rallentare , ma, a seconda del caso d'uso, potrebbe essere più lento rispetto alla versione compilata. Nella maggior parte dei casi interpretati lingue sono in realtà abbastanza veloce

"Abbastanza veloce", più l'aumento della produttività di utilizzare un linguaggio come Python sopra, ad esempio, C dovrebbe essere una giustificazione sufficiente per considerare un linguaggio interpretato. Inoltre, è sempre possibile sostituire alcune parti del programma interpretato con un'implementazione rapida C, se si ha realmente bisogno di velocità. Ma poi di nuovo, misurare e determinare se la velocità è veramente il problema, quindi ottimizzare.

Loop 100 volte, il contenuto del circuito siano interpretati 100 volte in codice di livello basso.

Non cache, non riutilizzato, non ottimizzato.

In termini semplici, un compilatore interpreta volta in codice di basso livello

Modifica, dopo i commenti:

JIT è compilato il codice , non interpretato. E 'appena compilato entro e non up-front
Mi riferisco alla definizione classica, non moderna implementazioni pratiche

In aggiunta alle altre risposte c'è ottimizzazione: quando si sta compilando un programma, di solito non importa quanto tempo ci vuole per compilare - il compilatore ha un sacco di tempo per ottimizzare il vostro codice. Quando stai interpretando il codice, che deve essere fatto molto velocemente quindi alcune delle ottimizzazioni più intelligente potrebbe non essere in grado di essere fatta.

Una domanda semplice, senza una vera risposta semplice. La linea di fondo è che tutti i computer davvero "capire" è istruzioni binarie, che è ciò lingue "veloci" come il C vengono compilati in.

Poi ci sono le macchine virtuali, che comprendere diverse istruzioni binarie (come Java e .NET), ma questi sono da tradurre al volo per istruzioni macchina da un Just-In-compilatore (JIT). Che è quasi veloce (ancora più veloce in alcuni casi specifici, perché il JIT ha più informazioni di un compilatore statico su come viene utilizzato il codice.)

Poi ci sono interpretati lingue, che hanno di solito anche le proprie istruzioni binarie intermedi, ma le funzioni di interprete molto simile a un ciclo con un grande switch in essa con un caso per ogni istruzione, e come eseguirlo. Questo livello di astrazione sul codice macchina sottostante è lenta. Ci sono più istruzioni coinvolti, lunghe catene di chiamate di funzione a livello di interprete di fare anche le cose semplici, e si può sostenere che la memoria e la cache non vengono utilizzati nel modo più efficace di conseguenza.

Ma interpretati lingue sono spesso abbastanza veloce per gli scopi per cui sono utilizzati. Le applicazioni Web sono sempre vincolati da IO (di solito l'accesso al database), che è un ordine di grandezza più lento rispetto a qualsiasi interprete.

Non v'è alcuna cosa come un linguaggio interpretato. Ogni lingua può essere implementata da un interprete o un compilatore. In questi giorni la maggior parte delle lingue hanno delle implementazioni che utilizzano un compilatore.

Detto questo, gli interpreti sono generalmente più lenta, perché hanno bisogno di elaborare la lingua o qualcosa di vicino ad esso in fase di esecuzione e tradurre al istruzioni macchina. Un compilatore fa questa traduzione di istruzioni macchina solo una volta, dopo che essi sono eseguiti direttamente.

about.com :

un linguaggio interpretato viene elaborato in fase di esecuzione. Ogni linea viene letta, analizzato, ed eseguito. dover rielaborare una linea ogni volta in un ciclo è ciò che rende linguaggi interpretati in modo lento. Questo overhead significa che codice interpretato corre tra 5 - 10 volte più lento di codice compilato. Il linguaggi interpretati come Basic o JavaScript sono il più lento. Loro vantaggio non dover essere ricompilati dopo le modifiche e che è utile quando si sta imparando a programmare.

I 5-10 volte più lento non è necessariamente vero per linguaggi come Java e C #, però. Essi sono interpretati, ma il just-in-time possono generare linguaggio macchina istruzioni per alcune operazioni, accelerando le cose drammaticamente (vicino alla velocità di un linguaggio compilato a volte).

I linguaggi interpretati bisogno di leggere e interpretare il codice sorgente al momento dell'esecuzione. Con codice compilato un sacco di tale interpretazione è fatta prima del tempo (al momento della compilazione).

Molto pochi linguaggi di scripting contemporanea sono "interpretati" in questi giorni; stanno in genere compilati al volo, sia in codice macchina o in qualche linguaggio bytecode intermedio, che è (più efficiente) eseguito in una macchina virtuale.

Detto questo, sono più lento perché la CPU sta eseguendo molte più istruzioni per "riga di codice", dal momento che molte delle istruzioni sono spesi comprendere il codice, piuttosto che fare tutto ciò che la semantica della linea suggeriscono!

Leggere questo e contro di linguaggi interpretati

Questa è l'idea rilevante in questo post al vostro problema.

Un'esecuzione da un interprete è di solito molto meno efficiente, allora esecuzione del programma regolare. Succede perché o ogni istruzione dovrebbe passare a un'interpretazione runtime o come nel più recente implementazioni, il codice deve essere compilato per un intermedio rappresentazione prima di ogni esecuzione.

Per la stessa ragione per cui è più lento di parlare tramite traduttore che in lingua madre. Oppure, la lettura con il dizionario. Ci vuole tempo per tradurre.

Aggiornamento: no, non ho visto che la mia risposta è la stessa di quella accettata, ad un grado; -)

Si, linguaggi interpretati sono lenti ...

Tuttavia, considerare quanto segue. Ho avuto un problema da risolvere. Mi ci sono voluti 4 minuti per risolvere il problema in Python, e il programma ha preso 0,15 secondi per l'esecuzione. Poi ho provato a scrivere in C, e ho avuto un tempo di esecuzione di 0,12 secondi, e ci ho messo 1 ora per scriverlo. Tutto questo perché il modo pratico per risolvere il problema in questione era quello di utilizzare tabelle hash, e la tabella hash dominato la fase di esecuzione in ogni caso.

Wikipedia dice ,

codice
Interpretazione è più lento in esecuzione il codice compilato perché il interprete deve analizzare ogni istruzione nel programma ogni volta che viene eseguito e quindi eseguire l'azione desiderata, mentre il codice compilato esegue solo l'azione in un contesto fissa determinata per la compilazione . Questa analisi runtime è noto come "sovraccarico interpretativa". L'accesso alle variabili è anche più lento in un interprete perché la mappatura di identificatori a posizioni di memoria deve essere fatto più volte in fase di esecuzione, piuttosto che in fase di compilazione.

IBM doc ,

programma interpretata deve essere tradotto ogni volta che viene eseguito, c'è un overhead maggiore. Così, un linguaggio interpretato è generalmente più adatto alle richieste ad hoc di richieste predefinite.

In Java anche se è considerato come un linguaggio interpretato, utilizza JIT (Just-in-time) la compilazione, che a mitigare il problema di cui sopra, utilizzando una tecnica di caching per memorizzare nella cache il bytecode compilato.

Il compilatore JIT legge i bytecode in molte sezioni (o per intero, raramente) e li compila in modo dinamico in codice macchina in modo che il programma può essere eseguito più velocemente. Questo può essere fatto per file, per-funzione o anche su qualsiasi frammento di codice arbitrario; il codice può essere compilato quando sta per essere eseguita (da qui il nome "just in time"), e quindi memorizzato nella cache e riutilizzato senza bisogno di ricompilazione.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow