Emulador

En informàtica, un emulador és un software que permet eixecutar programes o videojocs en una plataforma (siga una arquitectura de hardware o un sistema operatiu) diferent d'aquella per a la qual varen ser escrits originalment.^[1] A diferència d'un simulador, que solament tracta de reproduir el comportament del programa, un emulador tracta de modelar de forma precisa el dispositiu de manera que este funcione com si estiguera sent usat en l'aparat original.^[2]

Usos

Un us popular dels emuladors és el d'imitar l'experiència dels videojocs de màquines recreatives o videoconsoles en computadores personals, o el poder ser jugats en atres videoconsoles. L'emulació de videojocs de sistemes antics (abandonware) en les modernes computadores personals i videoconsoles de hui dia resulta generalment més cómoda i pràctica que en els dispositius originals. No obstant, pot ser requerit als creadors d'emuladors una llicència de software per a escriure programes originals que dupliquen la funcionabilitat de la ROM i BIOS del hardware original, lo que comunament es coneix com high-level emulation o emulació d'alt nivell.

Un atre us comú és el d'emular sistemes operatius obsolets, o vigents per a una atra màquina o dispositiu, per a utilisar programes compatibles en estos sistemes operatius.

Emulació

En sentit teòric, la tesis de Church-Turing implica que qualsevol ambient funcional pot ser emulat dins de qualsevol un atre. En la pràctica, açò pot resultar realment difícil, particularment quan el comportament exacte del sistema emulat no està documentat i deu ser deduït per mig d'ingenieria inversa. Tampoc es parla en la tesis sobre les diferències en sincronisació; si l'emulador no actua tan ràpidament com l'hardware original, el software d'emulació va a anar més llent que si fora el hardware original.

Estructura

La majoria dels emuladors solament emulen una determinada configuració arquitectura de hardware - si el sistema d'explotació (o sistema operatiu) també es requerix per a emular cert programa llavors ha de ser emulat també. Tant el sistema d'explotació com el programa deuen ser interpretats per l'emulador, com si estiguera eixecutant-se en l'equip original. Aparte de l'interpretació del llenguage de la màquina emulada, cal emular el restant de l'equip, com els dispositius d'entrada i eixida, de forma virtual: si escriure en una regió específica de la memòria deu influir en el contingut en pantalla, per eixemple, açò també deu ser emulat.

En lloc d'una emulació completa de l'equip, una compatibilitat superficial pot ser suficient. Açò traduïx les cridades del sistema emulat a cridades del sistema amfitrió.

Els desenrolladors de programes per a màquines en sistemes computarizados i consoles de videojoc comunament utilisen emuladors especialment exactes cridats simuladors abans d'eixecutar-los en l'equip real. Açò permet que el programa puga ser produït i provat ans que la versió final de l'equip per al qual s'està desenrollant siga produïda en grans cantitats, d'esta forma pot ser provat sense tindre que copiar el programa en l'equip, de modo que puguen ser eliminats errors en un nivell baix sense tindre els efectes colaterals d'un depurador.^[3]

Típicament, un emulador es dividix en mòduls que corresponen de forma precisa als subsistema de l'equip emulat. Lo més comú, és que un emulador este compost pels següents mòduls:

Un emulador de l'unitat central de processament.
Un mòdul per a el subsistema de memòria.
Varis emuladors per als dispositius d'entrada i eixida.

Lo més comú és que els busos no siguen emulats, per raons de simplicitat i rendiment, i per a que els perifèrics virtuals es comuniquen directament en la UCP i els subsistema de memòria.

Simulador de CPU

El simulador de l'unitat central de processament (CPU) és a sovint la part més complexa d'un emulador. Molts emuladors són escrits utilisant simuladors de CPU "preempaquetados", per a aixina poder realisar 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 seguix el fluix d'eixecució del còdic de programació emulat i, per cada instrucció de còdic de la màquina emulada, eixecuta en el processador en que es carrega, instruccions semánticament equivalents a les originals.

Açò és possible assignant una variable a cada registre i flag de la CPU emulada. La llògica de la CPU simulada pot ser més o menys traduïda directament a algoritmes de software, creant una reimplementaació del software que bàsicament reflectix l'implementació original del hardware.

L'eixemple següent ilustra el modo en que la simulació de CPU per un intérpret. En este cas, les interrupcions es revisen despuix de l'eixecució de cada instrucció, encara que este 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, ya que són més senzills d'implementar que atres solucions alternatives de millor rendiment, i la seua velocitat és més que adequada per a emular computadores de fa més d'una década en màquines modernes.

Aixina i tot, la penalisació de velocitat inherent en l'interpretació pot ser un problema en emular computadors la velocitat dels quals de processador està en el mateix orde de magnitut que la màquina hoste. Fins a no fa tants anys, l'emulació en tals situacions era considerada impracticable.

Lo que permet el rompimiento d'esta restricció són les tècniques alvançades de recompilación dinàmica. Una translació simple a priori del còdic del programa emulat al còdic que corre en l'arquitectura original és usualment impossible per vàries raons:

el còdic pot ser automodificable
no existix una forma que distinguixca de forma confiable els segments d'informació (que no deuen ser traduïts) dels segments de text (segments de còdic)

no existix forma de comunicar-se en el sistema operatiu emulat per a que l'emulador reconega els nous còdics carregats (per eixemple del disc)

Vàries formes de recompilación dinàmica, incloent la popular tècnica de compilació en temps d'eixecució (compilació JIT), tracta de vorejar estos temes esperant fins que el procés de control de fluix es moga fins a a on està la part a on està localisat el còdic sense traduir, i és solament llavors {"en temps d'eixecució") quan els blocs traduïts del còdic al còdic amfitrió poden ser eixecutats.

El còdic traduït es manté en el còdic caché, i el còdic original no es pert ni és afectat; d'esta forma, inclús els segments de data poden ser traslladats pel recompilador, resultant solament en una despesa de temps de trasllat.

Dispositius d'entrada i eixida

La majoria dels emuladors, com dit anteriorment, no emulen el sistema principal bus; cada dispositiu d'entrada i eixida és tractat a sovint com un cas especial, i no existix un interfaç constant per als perifèrics virtuals.

Açò pot resultar en una ventaja en el funcionament, proveint que cada mòdul d'entrada i eixida puga ser adaptat a les característiques del dispositiu emulat; dissenys basats en un estàndart, entrades i eixides unificades per mig d'API poden no obstant proveir models més simples, i ademés tenen la ventaja adicional de permetre de forma "automàtica" l'utilisació de servicis plugins per a proveir dispositius virtuals de tercers en l'emulador.

Les entrades i eixides unificades per mig d'API no necessàriament reflectixen l'estructura del bus del hardware real: el disseny del bus està llimitat per varis paràmetros elèctrics i la necessitat del maneig de programació paralela que la majoria de les voltes pot ser ignorada en l'implementació del software.

Encara els emuladors que tracten cada dispositiu com un cas especial posseïxen una infraestructura bàsica en comuna per a això:

manejant interruptors, per mig de procediments que fixen banderes llegibles pel simulador de el CPU sempre que un interruptor siga alçat, permetent a el CPU virtual "convertir els interruptors (virtuals)".
escrivint i llegint de la memòria física, per mig de dos procediments similars mentres este brega en la memòria llògica (contrari a este últim, l'anterior pugues comunament ser tirat a un costat, i en el seu lloc s'ampren les referències directes a l'apany de memòria)

Sistema de ROM

Erro al crear miniatura:

NeoRAGEx, emulador a pur d'imàgens ROM.

Els emuladors arranquen imàgens ROM, o siga el contingut dels cartuchos, disquets o cintes que s'usaven en els sistemes antics. Físicament en les PC les ROM són archius binaris que es poden carregar en la memòria. És dir, l'emulador és un programa que fa les funcions d'una consola, per eixemple la Game Boy Advance o una PDA, i la ROM és un archiu que fa de cartuig, CD-ROM, o cinta, per eixemple Mario Bros..

Vore també

Referències

↑ «Qué és un emulador digital i para qué pots utilisar-ho» (en és). ElDiario.és. Consultat el 2022-05-21.
↑ «Qué és un emulador i para qué s'utilisa» (en és). Culturación. Consultat el 2022-08-18.
↑ «Emuladors: Unes ferramentes imprescindibles».Món electrònic.(309)
80–83.ISSN 0300-3787.Consultat el 2022-05-21.

Este artícul conté una traducció derivada de «Emulador» de Wikipedia en castellà publicada baix la Llicència de documentació lliure de GNU i la Llicència Creative Commons Reconeiximent-CompartirIgual 4.0 Internacional.

[1] «Qué és un emulador digital i para qué pots utilisar-ho» (en és). ElDiario.és. Consultat el 2022-05-21.

[2] «Qué és un emulador i para qué s'utilisa» (en és). Culturación. Consultat el 2022-08-18.

[3] «Emuladors: Unes ferramentes imprescindibles».Món electrònic.(309)
80–83.ISSN 0300-3787.Consultat el 2022-05-21.

[1]

[2]

[3]