Emulador de codi

La majoria dels emuladors només emulen una determinada configuració arquitectura de maquinari - si el sistema d'explotació (o sistema operatiu) també es requereix per a emular cert programa de llavors ha de ser emulat també. Tant el sistema d'explotació com el programa han de ser interpretats per l'emulador, com si estigués executant en l'equip original. A part de la interpretació del llenguatge de la màquina emulada, cal emular la resta de l'equip, com els dispositius d'entrada i sortida, de forma virtual: si escriure en una regió específica de la memòria ha d'influir en el contingut en pantalla, per exemple, això també ha de ser emulat.

En comptes d'una emulació completa de l'equip, una compatibilitat superficial pot ser suficient. Això tradueix les crides al sistema emulat a crides al sistema amfitrió.

Els desenvolupadors de programes per a màquines amb sistemes computats i consoles de videojoc comunament utilitzen emuladors especialment exactes anomenats simulador és abans d'executar en l'equip real. Això permet que el programa pugui ser produït i provat abans que la versió final de l'equip per al qual s'està desenvolupant sigui produïda en grans quantitats, d'aquesta manera pot ser provat sense haver de copiar el programa a l'equip, de manera que puguin ser eliminats errors en un nivell baix sense tenir els efectes col·laterals d'un depurador.

Típicament, un emulador es divideix en mòduls que corresponen de manera precisa als subsistemes de l'equip emulat. El més comú, és que un emulador aquest compost pels següents mòduls:

• • Un emulador de CPU o un simulador d'UCP (tots dos termes són en la majoria dels casos intercanviables).
  • Un mòdul per al subsistema de memòria.
  • Diversos emuladors per als dispositius d'entrada i sortida.

El més comú és que els Buses no siguin emulats, per raons de simplicitat i rendiment, i perquè els perifèric virtuals es comuniquin directament amb la UCP i els subsistemes de memòria.

El Simulador de CPU (Unitat Central de Procés) és sovint la part més complexa d'un emulador. Molts emuladors són escrits utilitzant simuladors de CPU "pre-empaquetat", per així poder realitzar una emulació fidel i eficient d'una màquina específica.

El simulador de CPU més simple seria un Intèrpret informàtic, que segueix el flux d'execució del codi de programació emulat i, per cada instrucció de codi de la màquina emulada, s'executa en el processador en què es carrega, instruccions semànticament equivalents a les originals.

Això és possible assignant una variable a cada registre i flag de la CPU simulada. La lògica de la CPU simulada pot ser més o menys traduïda directament a algorismes de programari, creant una re-implementació del programari que bàsicament reflecteix la implementació original de l'maquinari.

L'exemple següent il·lustra la manera com la simulació de CPU per un intèrpret. En aquest cas, les interrupcions es revisen després de l'execució de cada instrucció, encara que aquest comportament no és usual en els emuladors en la realitat, per raons de rendiment.

 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;
 }
}

Els intèrprets són molt populars en el cas dels simuladors de CPU, ja que són més senzills d'implementar que altres solucions alternatives de millor rendiment, i la seva velocitat és més que adequada per a emular computadares de fa més d'una dècada a màquines modernes.

Tot i així, la penalització de velocitat inherent en la interpretació pot ser un problema en emular computadors la velocitat de processador està en el mateix ordre de magnitud que la màquina hoste. Fins no fa tants anys, l'emulació en aquestes situacions era considerada impracticable.

El que permet el trencament d'aquesta restricció són les tècniques avançades de recompilació dinàmica . Una translació simple a priori del codi del programa emulat al codi que corre en l'arquitectura original és normalment impossible per diverses raons:

• El codi pot ser auto modificable
• No hi ha una manera que distingeixi de manera fiable els segments d'informació (que no han de ser traduïts) dels segments de text (segments de codi)
• No hi ha manera de comunicar-se amb el sistema operatiu emulat perquè l'emulador reconegui els nous codis carregats (per exemple del disc)

Diverses formes de recompilació dinàmica, incloent la popular tècnica de compilació en temps d'execució (compilació JIT), tracta de vorejar aquests temes esperant fins que el procés de control de flux es mogui fins on aquesta la part on està localitzat el codi sense traduir, i és només llavors{"en temps d'execució") quan els blocs traduïts del codi al codi amfitrió poden ser executats.

El codi traduït es manté en l' codi cache , i el codi original no es perd ni és afectat; d'aquesta manera, fins i tot els segments de data poden ser traslladats pel recompilar, resultant només en una despesa de temps de trasllat.

La majoria dels emuladors, com dit anteriorment, no emulen el sistema principal bus; cada dispositiu d'entrada i sortida és tractat sovint com un cas especial, i no hi ha una interfície constant per als perifèrics virtuals.

Això pot resultar en un avantatge en el funcionament, proveint que cada mòdul d'entrada i sortida pugui ser adaptat a les característiques del dispositiu emulat; dissenys basats en un estàndard, entrades i sortides unificades per mitjà d'API poden però proveir models més simples, ia més tenen l'avantatge addicional de permetre de forma "automàtica" la utilització de serveis plugin s per a proveir dispositius virtuals de tercers en l'emulador.

Les entrades i sortides unificades per mitjà d'API no necessàriament reflecteixen l'estructura del bus del maquinari real: el disseny del bus està limitat per diversos paràmetres elèctrics i la necessitat del maneig de programació paral·lela que l'majoria de les vegades pot ser ignorada en la implementació del programari.

Encara els emuladors que tracten cada dispositiu com un cas especial tenen una infraestructura bàsica en comú per a això:

• Manejant interruptor és, per mitjà de procediments que fixin banderes llegibles pel simulador de la CPU sempre que un interruptor sigui aixecat, permetent al CPU virtual "convertir els interruptors (virtuals)".
• Escrivint i llegint de la memòria física, per mitjà de dos procediments similars mentre aquest brega amb la memòria lògica (contrari a aquest últim, l'anterior pot comunament ser fet fora a una banda, i en el seu lloc es fan servir les referències directes a l'arranjament de memòria)

Els emuladors arrenquen imatges ROM (o simplement ROM), és a dir el contingut dels cartutxos, disquets o cintes que es feien servir amb els sistemes antics. Físicament en les PC les ROM són fitxers binaris que es poden carregar a la memòria. És a dir, l'emulador és un programa que fa les funcions de la consola, per exemple la Game Boy Advance o una PDA, i la ROM és un arxiu que fa de cartutx, CD-ROM, o cinta, per exemple "Mario Bros".

També hi ha una vessant en l'emulació que pot ser realitzada per virtualització, consistent a crear una capa d'abstracció, però executant instruccions en una màquina del mateix tipus, i dona com a resultats obtenir un ordinador dins d'una altra. Exemples d'això són:

• VMware
• Microsoft Virtual PC
• Bochs
• VirtualBox

Els emuladors de consoles són programes d'ordinadors dissenyats per a emular una o més consoles i així poder jugar un joc que pertany a aquesta (s). Els emuladors múltiples solen emular consoles amb característiques similars (per exemple MEKae emula totes les consoles de Sega de 8 bits i la Colecovision)

• Dinàmica de sistemes

 

A Wikimedia Commons hi ha contingut multimèdia relatiu a: Emulador de codi

• Emulatronia - notícies sobre emuladors