Più difficile da costruire: emulatore o compilatore?

Question

Dato uno sviluppatore esperto con 10-20 anni di esperienza che non ha mai costruito né un compilatore o un emulatore, che sarebbe più di sfida?

Potresti confrontare i problemi che sarebbero blocchi stradali per entrambi.

Grazie.

Answer 1

emulazione e la compilazione sono molto diverse, ma tendono ad essere ammassati insieme a causa sia di essere considerato "a basso livello".

Emulazione di un'architettura semplice, come uno Z80 6502 o sarà abbastanza semplice per il pezzo CPU del lavoro, ma ci sarà un giusto pezzo di codice da scrivere in quanto è necessario disporre di una funzione per ogni istruzione. Avrai voglia di automatizzare questo, in qualche modo, da una specifica set di istruzioni di tutti i tempi e così via, come scrivendo questo tutti fuori sarà molto noioso in effetti :) Vecchio istruzioni della CPU set specifiche sono facili da trovare, quindi questo aiuta molto quando si costruisce emulatori.

Oltre a ciò è necessario implementare un certo livello di hardware emulazione , che di solito comporta la manipolazione e la generazione di interrupt (come l'interrupt verticale vuoto di un dispositivo di visualizzazione se l'emulatore è per una console di gioco, per esempio). Anche questo avrà bisogno di un certo livello di specifiche e generazione di codice, ma è probabile che sia di scrivere la maggior parte di questo a mano in quanto non sarà più così ripetitivo (e quindi automatizzabile) come il codice di set di istruzioni.

compilazione comporterà una sorta di linguaggio di specifica di qualsiasi lingua che si sta per essere l'attuazione del compilatore per, e un obiettivo che si cercherà di codice di uscita per. L'uscita potrebbe essere dritto al binario, potrebbe essere l'assemblaggio o potrebbe anche essere un'altra lingua (questo è davvero solo un traduttore, ma conta come la compilazione quando il bersaglio è considerato "sufficientemente"-basso livello). Dal momento che sarete in esecuzione su una sorta di piattaforma hardware o VM allora si sarà improbabile che devono preoccuparsi di gestione degli interrupt e cose del genere.

blocchi Barcollare per entrambi sono complessità e correttezza - per l'emulatore è necessario per farlo funzionare in modo molto preciso a meno che non si sceglie cose molto semplici da emulare. Avrete anche bisogno di creare una sorta di debugger integrato per l'emulatore, altrimenti è quasi impossibile dire cosa non va quando lo fa sempre così. Per un compilatore dovrebbe essere abbastanza straightforwward di tradurre un linguaggio giocattolo o un piccolo sottoinsieme di un linguaggio più complesso, e costruire in su come si va avanti.

Ricordate che, con entrambi questi elementi è necessario essere in grado di produrre in ingresso per metterli alla prova, e se non si può produrre semplici input allora lo troverete molto difficile ottenere il debug fin dall'inizio. Questo da solo rende il lavoro del compilatore più facile entrare in, imho (Questo, e che si vuole avere qualcosa che emula una console completa o qualcosa subito:)

Answer 2

ho scritto entrambi e direi che a parità di condizioni (complessità del linguaggio o set di istruzioni), è via più facile scrivere un emulatore, soprattutto se si sta cercando di scrivere un interessante emulatore o compilatore.

Il motivo è che con un emulatore si sta cercando di simulare una cosa di basso livello con un altro, simile cosa di basso livello. Non è troppo male. Con un compilatore, si può tentare di realizzare idee stesse di alto livello (ad esempio, gli oggetti, le funzioni di prima classe, memoria gestita, stringa di scansione) con strumenti di livello molto basso (parole della macchina e istruzioni macchina). Questo compito è solo molto più difficile.

Naturalmente, per le bande di divertimento, è possibile scrivere un emulatore che funziona da dinamica traduzione binaria , che è la compilazione di codice macchina per l'architettura emulato in codice macchina per l'architettura nativa. In questo modo si arriva ad avere tutto il divertimento di entrambi --- e yo produrre emulatori davvero veloci come QEMU o il compianto Digital FX! 32.

Answer 3

ho scritto entrambi e direi che un emulatore è generalmente più facile. Naturalmente, questo dipende molto da cosa si sta cercando di emulare (emulando un mainframe IBM su un iPhone potrebbe essere un po 'una sfida) e ciò che si sta cercando di compilare (un piccolo compilatore C è abbastanza facile, una full compilatore C ++ quasi incredibilmente difficile.

Answer 4

E 'dipende in gran parte ciò che si sta emulando, e ciò che si sta compilando.

• Un emulatore che emula un sistema molto semplice (ad esempio una calcolatrice a 4 funzioni) su un sistema molto capace (per esempio un moderno PC) sarà facile scrivere.
• Un compilatore che compila un linguaggio molto semplice per un singolo bersaglio (ad esempio qualcosa che mappa quasi direttamente al gruppo di uscita) sarà facile scrivere.
• Un emulatore che emula un sistema molto complesso (ad esempio un grande sistema di calcolo brevettato) in un sistema molto semplice (per esempio un PDA) sarà molto difficile da scrivere
• Un compilatore che compila un linguaggio di alto livello (ad esempio completa C ++) per molti obiettivi sarà molto difficile da scrivere

Answer 5

A mio parere un compilatore complesso è più difficile scrivere di un emulatore complessa per la semplice ragione che il compilatore coinvolge molto più teoria.

Nel progettare la vostra lingua XX c'è un sacco di fattori da considerare per non parlare di ottimizzare l'output del codice generato compilatore che è una magia nera in sé. Con un emulatore si dispone di un ambiente già ben definito con un linguaggio per lo più ben definito che si desidera implementare.

In ogni caso vi consiglio a chiunque di scrivere e scrivere un compilatore perché ti dà una comprensione più profonda di programmazione, proprio come il medico ha bisogno di sapere circa l'anatomia del corpo, anche se egli non può avere bisogno nel suo lavoro quotidiano.

EDIT: Penso che entrambe le abilità sono molto utili e si può effettivamente combinarli - non sono XOR.

Vorrei aggiungere il mio parere di cui sopra è che la creazione di un linguaggio di programmazione non banale tra cui runtime-librerie di interagire con i driver, database, ecc e che può evolvere con le versioni future ma rimangono ancora compatibile è uno dei più impegnativo aree in CS.

Sono anche d'accordo che se la piattaforma è sconosciuta vale a dire sei reverse engineering qualcosa, allora è molto più difficile da fare un emulatore, ma OTOH non è questo che la domanda di OP era circa, vero?

Answer 6

L'emulazione del software è abbastanza straight-forward e così relativamente facile, ma può essere noioso.

Scrivi compilatore può essere molto difficile, ma è fatta più semplice, sia avendo un buon lavoro-conoscenza o di avere un buon set di specifiche (ad esempio, Backus-Naur Form notazione) della lingua che si sta scrivendo il compilatore per.

L'emulazione di hardware può essere estremamente difficile, se il vostro obiettivo è quello di rendere il lavoro emulatore su molte piattaforme differenti (ad esempio, in esecuzione l'emulazione di temporizzazione di un drive floppy-disk potrebbe funzionare sotto MSDOS utilizzando le costanti fondente corretti, ma l'emulazione non riesce su una piattaforma multi-tasking come Vista o Linux). emulazione hardware è anche estremamente difficile quando una conoscenza insufficiente è disponibile su come il suo modo di funzionamento è controllato da un software. Questo costringe reverse-engineering lungo e fastidioso prima che il progresso può essere fatto.

Tutto sommato, giudico l'emulazione di essere il più difficile.

Answer 7

Scrivere un emulatore per una piattaforma emulato noto che non è difficile (è anche possibile utilizzare un emulatore di pre-made CPU e guadagnare un po 'di tempo di sviluppo).

Scrivere un emulatore per sconosciuta emulato hardware è molto più difficile , e sposta la difficoltà a campi diversi da code-sviluppo: matematica, crittoanalisi, protocolli di sicurezza, ecc E, come sviluppatore, devi avere pazienza per il trial-and-error coinvolti nel processo.

A titolo di esempio, basti pensare a quanto tempo CPS2 emulazione richiesta (ROM CPS2 erano criptato).

Answer 8

Fuori contesto, non ci possono essere risposte certe:. Tutto dipende da ciò che si vuole raggiungere, e che cosa sei in competizione contro

Se è solo un "proof of concept", quindi in entrambi i casi, è abbastanza semplice.

Ma se si sta cercando di emulare l'hardware di un complesso o con elevata precisione, o se si vuole raggiungere la qualità di compilazione AAA, le cose possono diventare rapidamente di brutto complessità. La complessità apparirà non solo nel algoritmi / teoria del codice "principale", ma anche in tutti gli strumenti di supporto si dovrà costruire (debugger, profiler, disassemblatori, ecc) in modo da poter avanzare al passo successivo.

Detto questo, un altro aspetto da considerare è che scrivere un compilatore che lavora per quasi qualsiasi linguaggio di programmazione là fuori è di complessità ragionevole. D'altra parte, se non v'è l'hardware là fuori che è banale di emulare, c'è anche l'hardware per il quale la scrittura anche un emulatore di base può essere molto complesso.

Quindi, la pittura con un pennello largo, direi scrivendo un compilatore è più facile, perché si sta praticamente la garanzia di riuscire a ottenere una versione funzionante, indipendentemente dall'hardware o la lingua di destinazione. Non esiste una garanzia per un emulatore.

Answer 9

Scrivi compilatore è molto più difficile, dal momento che hai a che fare con roba molto più basso livello (che collega, il montaggio che è specifico per l'architettura, ecc).

Un emulatore deve solo eseguire la logica di ogni istruzione alimentato ad esso (e so che sto semplificando questo, ma suppongo di avere le specifiche per il set di istruzioni), oggi, a scrivere un emulatore veloce è molto più difficile.