Emulatore: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
Nessun oggetto della modifica |
Etichette: Annullato Modifica visuale Link a pagina di disambiguazione |
||
Riga 20:
{{vedi anche|Retrogaming}}
Un uso popolare degli emulatori è quello che permette di utilizzare [[videogioco|videogiochi]] scritti per computer o [[Console (videogiochi)|console]] non più in vendita o di difficile reperibilità, come i computer della serie [[Amiga]], il [[Commodore 64]], lo [[ZX Spectrum]], il [[BBC Micro]], l'[[MSX]], la [[PlayStation|PSX]] e le vecchie console [[Nintendo]].
=== Struttura ===
La maggior parte degli emulatori emula solo una determinata configurazione dell'architettura hardware: se anche il sistema operativo (o il [[sistema operativo]]) è richiesto per emulare un determinato programma, allora deve essere emulato anche lui. Sia il sistema operativo che il programma devono essere interpretati dall'emulatore, come se fosse in esecuzione sul computer originale. Oltre a interpretare il linguaggio della macchina emulata, il resto dell'attrezzatura, come i dispositivi di input e output, deve essere emulato [[Macchina virtuale|virtualmente]]: se la scrittura in una specifica regione di [[Memoria (elettronica)|memoria]] dovesse influenzare il contenuto sullo schermo, ad esempio, questo deve essere emulato.
Invece di un'emulazione completa dell'apparecchiatura, può bastare una compatibilità superficiale. Questo converte le chiamate di sistema emulate in chiamate di sistema host.
Gli sviluppatori di programmi per sistemi informatici e console per videogiochi utilizzano comunemente emulatori particolarmente esatti chiamati simulatori prima di eseguirli sul computer reale. Ciò consente al programma di essere prodotto e testato prima che la versione finale del computer per il quale è stato sviluppato venga prodotta in gran numero, quindi può essere testato senza dover copiare il programma sul computer, quindi possono essere sottoposti a debug a un basso livello senza avere gli effetti collaterali di un [[debugger]].
Tipicamente, un emulatore è suddiviso in moduli che corrispondono esattamente ai sottosistemi del computer emulato. Il più comune è che un emulatore è composto dai seguenti moduli:
* Un emulatore di unità di elaborazione centrale.
* Un modulo per il sottosistema di memoria.
* Vari emulatori per dispositivi di input e output.
Il più comune è che i bus non vengono emulati, per motivi di semplicità e prestazioni, e per consentire alle periferiche virtuali di comunicare direttamente con la CPU ei sottosistemi di memoria.
=== simulatore di cpu ===
Il simulatore di [[CPU|unità di elaborazione centrale]] (CPU) è spesso la parte più complessa di un emulatore. Molti emulatori vengono scritti utilizzando simulatori di CPU "preconfezionati", in modo da eseguire un'emulazione fedele ed efficiente di una macchina specifica.
Il simulatore di CPU più semplice sarebbe un [[Interprete (informatica)|interprete]] per computer, che segue il flusso di esecuzione del codice di programmazione emulato e, per ogni istruzione di codice macchina emulato, esegue istruzioni semanticamente equivalenti all'originale sul processore in cui è caricato.
Ciò è possibile assegnando una [[Variabile (informatica)|variabile]] a ciascun [[Registro (informatica)|registro]] e flag della CPU emulata. La logica della CPU simulata può essere tradotta più o meno direttamente in algoritmi [[software]], creando una re-implementazione del software che sostanzialmente rispecchia l'implementazione hardware originale.
L'esempio seguente illustra come la CPU viene simulata da un interprete. In questo caso, gli interrupt vengono controllati dopo l'esecuzione di ogni istruzione, anche se questo comportamento non è in realtà negli emulatori, per motivi di prestazioni.
void Execute(void) {
if(Interrupt!=INT_NONE) {
SuperUser=TRUE;
WriteMemory(++StackPointer, ProgramCounter);
ProgramCounter=InterruptPointer;
}
switch(ReadMemory(ProgramCounter++)) {
// Handling of every valid instruction
default:
Interrupt=INT_ILLEGAL;
}
}
Gli interpreti sono molto popolari per i simulatori di CPU, in quanto sono più facili da implementare rispetto alle alternative più performanti e la loro velocità è più che adeguata per emulare i computer di oltre un decennio fa su macchine moderne.
Tuttavia, la riduzione della velocità intrinseca nel rendering può essere un problema quando si emulano computer la cui velocità del processore è dello stesso ordine di grandezza della macchina host. Fino a non molti anni fa, l'emulazione in tali situazioni era considerata impraticabile.
Ciò che consente la rottura di questa restrizione sono le tecniche avanzate di ricompilazione dinamica. Una semplice traduzione [[A priori e a posteriori|a priori]] del codice del programma emulato nel codice in esecuzione sull'architettura originale è solitamente impossibile per diversi motivi:
* el código puede ser auto modificable
* no existe una forma que distinga de forma confiable los segmentos de información (que no deben ser traducidos) de los segmentos de texto (segmentos de código)
* no existe forma de comunicarse con el sistema operativo emulado para que el emulador reconozca los nuevos códigos cargados (por ejemplo del disco)
Varie forme di ricompilazione dinamica, inclusa la popolare tecnica di [[Compilatore just-in-time]] (compilazione JIT), cercano di aggirare questi problemi aspettando che il processo del flusso di controllo si sposti nel punto in cui si trova il codice non tradotto, e solo allora {"in fase di esecuzione") che i blocchi di codice tradotti nel codice host possono essere eseguiti.
Il codice tradotto viene conservato nella [[cache]] del codice e il codice originale non viene perso o alterato; in questo modo, anche i segmenti di dati possono essere spostati dal ricompilatore, con un conseguente dispendio di tempo per lo spostamento.
=== dispositivi di input e output ===
La maggior parte degli emulatori, come detto sopra, non emula il bus di sistema principale; ogni dispositivo di input e output viene spesso trattato come un caso speciale e non esiste un'interfaccia costante con le [[Periferica|periferiche]] virtuali.
Ciò può comportare un vantaggio in termini di prestazioni, a condizione che ciascun modulo di ingresso e di uscita possa essere adattato alle caratteristiche del dispositivo emulato; I progetti basati su standard, l'I/O unificato tramite API possono tuttavia fornire modelli più semplici e hanno l'ulteriore vantaggio di consentire l'uso "automatico" dei servizi di [[Plugin (informatica)|plugin]] per fornire dispositivi virtuali di terze parti nell'emulatore.
Gli ingressi e le uscite unificati tramite [[API]] non riflettono necessariamente l'effettiva struttura del bus hardware: il design del bus è limitato da vari parametri elettrici e dalla necessità di una gestione della programmazione parallela che spesso può essere ignorata nell'implementazione del software.
Anche gli emulatori che trattano ogni dispositivo come un caso speciale hanno un'infrastruttura di base comune per farlo:
* pilotare [[Interruttore|switch]], mediante procedure che impostano flag leggibili dal simulatore di CPU ogni volta che viene sollevato uno switch, consentendo alla CPU virtuale di "convertire switch (virtuali)".
* scrittura e lettura dalla memoria fisica, mediante due procedure simili mentre si occupa della memoria logica (a differenza della seconda, la prima può essere comunemente tralasciata e vengono invece utilizzati riferimenti diretti all'array di memoria)
=== Sistema ROM ===
Gli emulatori avviano le [[immagini ROM]], ovvero il contenuto di cartucce, [[floppy disk]] o nastri utilizzati con i sistemi precedenti. Fisicamente, sui PC, le ROM sono file binari che possono essere caricati in memoria. Cioè l'emulatore è un programma che svolge le funzioni di una console, ad esempio il [[Game Boy Advance]] o un [[PDA]], e la ROM è un file che funge da cartuccia, [[CD-ROM]] o nastro, ad esempio Mario Bros.
== Emulatori famosi ==
| |||