Estudio de las técnicas de diseño
e implementación de emuladores
Victor Moya del Barrio
Proyecto de Fin de Carrera FIB UPC
2001
Objetivos
• Realizar un estudio de las técnicas usadas
para implementar emuladores de
computadoras lúdicas (vídeoconsolas,
máquinas arcade, microcomputadores).
• Implementar ejemplos prácticos de estas
técnicas.
Introducción (1)
• Introducción del concepto de emulador.
• Introducción a la estructura de un emulador.
• Emulación de la CPU:
– Emuladores Intérpretes.
– Traducción Binarios.
• Emulación de la memoria.
• Emulación del tiempo.
Introducción (2)
•
•
•
•
Emulación de las interrupciones y excepciones.
Emulación del hardware gráfico.
Emulación del hardware de sonido.
Introducción de otros conceptos relacionados con
la emulación.
• Presentación de las maquinas emuladas.
– Master System : MAS.
– Space Invaders: SI2001
¿Qué es un emulador?
• Emulador = programa software que intenta
reproducir el funcionamiento de una
computadora (origen) en otra computadora
(destino).
Reproducir
MÁQUINA
MÁQUINA
ORIGEN
Convertir
Traducir
DESTINO
Nuestra máquina origen (1)
• Vídeo consolas: computadoras de pequeña o
mediana potencia con preferencia en el
aspecto gráfico y de sonido.
• Máquinas arcade: versiones más potentes y
caras de la vídeo consolas, son las máquinas
que pueden encontrarse en los salones
recreativos.
• Microcomputadores o ordenadores caseros.
Nuestra máquina origen (2)
• Procesadores desde los 8-bit hasta los 32-bit
(las más modernas). Potencia mediana o
bajas.
• Los datos se almacenan en cartuchos con
ROMs (CD-ROM en las modernas).
• Gran importancia del hardware gráfico y de
sonido.
Nuestra máquina origen (3)
• Ejemplos:
– Videoconsolas: Sega Master System (8-bit),
Sega Genesis, Super Nintendo (16-bits).
– Arcade systems: NeoGeo , CPS1, CPS2 (16bit), Naomi (32-bits).
– Videoconsolas modernas: Play Station (32bits), DreamCast (32-bits).
– Ordenadores: Spectrum, MSX, Amiga, Atari
ST.
La máquina destino (1)
• Normalmente un PC o sistema similar.
• Tiene que ser mas potente que la máquina
emulada (mantener la velocidad real). Unas
10 veces como mínimo.
• Últimamente también se implementan
emuladores para las consolas (mayor
potencia).
Máquina destino (2)
• Características:
–
–
–
–
CPU potente.
Gran cantidad de memoria.
Gran cantidad de almacenamiento secundario.
Sistemas gráficos y de sonidos simples (excepto
modernas tarjetas 3D).
Estructura de un emulador
• Los componentes emulados trabajan en
paralelo en el sistema original.
• Algoritmo secuencial.
• Solución: entrelazar la ejecución de los
diferentes componentes.
Algoritmo básico
while (!end)
{
emularCPU();
emularGraficos();
emularSonido();
controlTiempo();
}
Emulación de la CPU (1)
• Dos formas de implementarla:
• Emulador intérprete: fetch-decode-executeloop. Fácil de implementar. Emulación
relativamente lenta.
• Solución: threaded code interpreters,
implementarlo en ensamblador.
Emulación de la CPU (2)
• Traducción binaria: convertir el código de la
CPU origen a código de la CPU destino.
• Difícil de implementar.
• Emulación muy rápida.
• Dos tipos: estática (traducir binarios) y
dinámica (en tiempo de ejecución).
Emuladores de CPU
• Algoritmo básico: fetch – decode- execute
• Fetch: leer el código de operación (opcode).
Tamaño fijo o tamaño variable de opcode.
• Decode: identificar la instrucción y sus
operandos. Switch-case. Jump Tables.
• Execute: emulación de la instrucción.
Instrucción
• Esquema básico de la ejecución una
instrucción:
obtenerOperandos()
realizarOperacion()
guardarResultado()
actualizarCiclosEjecutados()
Threaded code interpreters
• Overhead de un intérprete: cada instrucción
se decodifica tantas veces como se ejecuta
(costoso).
• Solución: guardar el resultado de la
decodificación (dirección de la rutina que
emula la instrucción + operandos).
• Threaded Code: Lista/Vector de direcciones
de código a ejecutar.
Threaded code
Lista de funciones a ejecutar
PC
Función
Se ejecuta código utilizando un índice a una
tabla de funciones (instrucciones de la CPU
origen decodificadas).
Ensamblador
•
Codificar las instrucciones o todo el
emulador en ensamblador para:
1) Aprovechar mejor las capacidades de la CPU
destino (flags).
2) Implementar más eficientemente el bucle
principal (fetch-decode). Se puede poner
inlined al final de la instrucción.
Traducción Binaria
• Dos métodos:
– Traducción Binaria Estática.
– Traducción Binaria Dinámica.
Traducción Estática (1)
• Leer el código del binario fuente y
convertirlo en código para la CPU destino.
Generar un nuevo binario.
• Semejante a un compilador: análisis léxico,
sintáctico, semántico, traducción a una IR,
optimización y generación de código.
• El traductor sustituye las fases de análisis
por la decodificación de instrucciones.
Traducción Estática (2)
• Dos componentes básicos:
– Traductor: genera el nuevo binario. Puede usar
información de profiling.
– Run-Time: soporte al código traducido.
Intérprete para el código no traducido.
Traducción Dinámica (1)
• Traducir sólo el código que se ejecuta o se
va a ejecutar.
• Dos alternativas:
– Usar un intérprete para recoger información
(bloques básicos, frecuencia de ejecución).
– Traducir todo el código que se ejecuta.
• Se traduce por bloques.
Traducción Dinámica (2)
• Componentes:
– Intérprete (opcional). Primera ejecución y
recopilar información.
– Traductor (usando IR o no). Traducir a la IR o
a código destino directamente.
– Cache de traducciones. Guardar los bloques
traducidos.
Traducción Binaria. Diferencias.
• Traducción estática produce mejor código
(más tiempo para realizar optimizaciones).
• Traducción estática requiere un mecanismo
para ejecutar código no traducido.
• Traducción dinámica permite realizar
optimizaciones dinámicas.
• Traducción dinámica es más flexible.
Emulación de la memoria.
• No toda la memoria puede ser accedida
linealmente.
• Zonas especiales: bancos, registros de IO.
• MMU.
• Lo más básico: usar una lista de regiones
con punteros a buffers o a funciones que
realicen el acceso.
Endianismo
• Se tiene que tener en cuenta el endianismo
de la CPU origen y destino.
• Little/Big endian.
• Realizar la conversión en cada acceso:
costoso.
• Convertir toda la memoria.
Endianismo
• Se tiene que tener en cuenta el endianismo
Palabra
a almacenar:
de la CPU
origen
y destino.0x12345678
• Little/Big endian.
0x12
0x34
0x56
0x78
• Realizar laPalabra
conversión
en cada acceso:
almacenada en formato Big-Endian
costoso.
• Convertir toda la memoria.
0x78
0x56
0x34
0x12
Palabra almacenada en formato LittleEndian
Endianismo
• Se tiene que tener en cuenta el endianismo
de la CPU origen y destino.
• Little/Big endian.
• Realizar la conversión en cada acceso:
costoso.
• Convertir toda la memoria.
Ejemplo endianismo
Palabra a almacenar: 0x12345678
0x12
0x34
0x56
0x78
Palabra almacenada en formato
Big-Endian
0x78
0x56
0x34
0x12
Palabra almacenada en formato
Little-Endian
Emulación del tiempo.
• Tiempo interno: se usa la CPU. Contar el
número de ciclos (instrucciones) emulados.
• Usar el número de ciclos emulados para
iniciar diferentes eventos (interrupciones,
emulación del sonido, gráficos).
• Tiempo externo: sensación del usuario.
Ajustar velocidad del emulador a velocidad
real.
Interrupciones y Excepciones
• Interrupciones: generadas por los
dispositivos. Se generan fuera de la
emulación de la CPU en respuesta a ciertos
eventos.
• Excepciones: las tiene que emular el
emulador de CPU. Errores y eventos
internos. MMU.
Emulación de los gráficos
• Es quizás el componente más importante
del emulador.
• Básicamente dos sistemas distintos:
– Basados en framebuffers: ordenadores y
consolas modernas.
– Basados en tiles/sprites (sistema parecido al
modo texto): consolas y arcades previos a la era
3D.
Sistemas basados en tiles
• El hardware gráfico intenta reducir el uso de CPU,
memoria y ancho de banda. Reusar.
• Diferentes ‘layers’ que se combinan usando
prioridades.
• Tile: rectángulo gráfico que cubre un layer,
posiciones fijas, background (fondo).
• Sprite: gráfico móvil rectangular. Sprite layer.
• Hardware dibuja línea a línea.
Layers
layers
pantalla
Prioridades
Ordenación
Ejemplo de sistema basado en
Tiles
Background (tiles)
Sprites
Ejemplo de sistema basado en
Sprites/Tiles
Los dos layers
(tiles y sprites)
se combinan
para formar la
imagen
Sistemas basados en framebuffers
• La imagen en pantalla se representa como
una matriz rectangular de puntos. Cada
punto tiene un valor de color.
• Paletas.
• Buffer primario y secundario.
• Blit: copiar datos al framebuffer.
Framebuffer
framebuffer
gráfico
blit
Emulación del Sonido
• Este componente suele considerarse como
opcional.
• Dos tipos de generación de sonido:
– Basada en waves (ondas): sonido FM y PSG
(Programmable Sound Generators). Consolas
de 8 y 16 bits.
– Basada en samples (muestreo del sonido):
ordenadores, consolas modernas. CD musical.
PSGs y sonido FM
• PSG: ondas básicas (sinusoidales,
cuadradas), genera notas simples. Pocos
canales. Número de efectos reducido.
• FM: ondas complejas (harmónicos). Se
combinan varias ondas para formar el
sonido. Envelope. Gran número de
canales. Basada en instrumentos. Diversos
efectos y filtros.
Samples
• El sonido está almacenado como muestras
digitales.
• El hardware lee los samples de un buffer
(bits por sample, canales y frecuencia) y lo
reproduce. Timers, interrupciones.
• Diversos niveles de complejidad. Mezcla
por hardware o no, filtros, efectos.
Otros aspectos a tener en cuenta
• Información de la máquina a emular:
¿difícil de conseguir?.
• Ingeniería inversa.
• Depuración y corrección de errores:
complejo.
• Aspectos legales.
• Emuladores comerciales.
Conclusiones
• El estudio consigue mostrar las técnicas
necesarias para la emulación de una
computadora.
• La emulación de sistemas de juego antiguos
tiene éxito.
• Diferentes aplicaciones comerciales:
portabilidad, competencia entre fabricantes
de CPU, etc.
Emuladores Implementados (1)
• Estos emuladores pueden encontrarse en el
CD adjunto a la memoria.
• Emulador de Sega Master System
– Vídeo consola fabricada a partir de 1982 por
Sega. Procesador Z80 a 3.57 MHz (8bits).
Hardware gráfico basado en tiles (background
layer y sprite layer). Sonido: PSG y FM
(Model 3)
Emuladores Implementados (2)
• Space Invaders
– Maquina arcade del 1978. Procesador Intel
8080 a 2 Mhz. Sistema gráfico basado en un
framebuffer monocromático. Sonido generado
por circuitos discretos (fijos).
Vídeo Consolas
NES
SNES
N64
6502,
Master
PSG,
System
VDP, ROMsZ80, VDP, PSG
Turbo
Graph
685c2,
VDP
+
FX,
M68000,
DSP
VDP, FM
Genesis
2xM68000, SH2,
MegaCD/32X
VDP + FX, FM, PCM
2xSH2, M68000, VDP,
Saturn
MIPS R4300, RCP,
MIPS R3000, GTE
PSX
3D,
DSP
RDRAM
SH4, ARM7, NECEE
VR2
(MIPS, VPU1, VPU2)
PS2
RDRAM
Gekko (PPC 750), Flipper
PIII 733, NVIDIA XBOX
(ATI)
NV17, UMA
Dreamcast
GameCube
Arcade
First Generation (Discrete Circuits)
First 8-bit Generation. Discrete Logic. (8080, 8085, Z80)
Second 8-bit Generation. VDPs. PSG/FM. (Z80, 6502, 6809)
16-bit Generation. VDP. FM and DSPs. (M68000)
First 32 bit. 3D Graphics. DSPs. (Nec V60, Nec V70, SH2,
PowerPC 603, Intel I960)
Last generation. 3D Graphics. DSPs. (SH4, MIPS, EE)
Dreamcast
• Ultima videoconsola de Sega.
• Main CPU: Hitachi SH4 200 MHz (360 MIPs, 1,4
GFLOPS). 5-Stage, 2-way superscalar. L1 8KB
Instr. 16 KB Data. 32-bit Integer Unit. 64-bit FP
Unit. 800 MB/s. 0.25um four layer CMOS.
• Sound CPU: Yamaha ARM7 45 MHz.
• 3D: 100 MHz Nec PowerVR2.
• Memory: SDRAM 100 MHz. 16 MB (main), 8
MB (video), 2 MB (audio).
Play Station 2
• Segunda videoconsola de Sony.
• Emotion Engine: MIPS R5900 (MIPS III, MIPS
IV subset + 128 bits SIMD 32x128bit) 2-issue, 2
64-bit IU, 1 FPU, 6 stages. L1: 16KB/8KB. VU0
(VLIW, Vector Unit, 4 FMACs, 1 FDIV,
4KB/4KB), VPU1 (VLIW, Vector Unit + Scalar
FP, 5 FMACs, 2 FDIV, 16KB/16KB). 300 MHz,
6,2 GFLOPS.
• Memoria: 32 MB DRDRAM, 3,2 GB/s.
• I/O: MIPS R3000 33 MHz (PSX Integrada).
Game Cube
• Nintendo last one.
• Gekko: IBM PowerPC 750 32-bits integer + 64
bits (2x32) FP. 485 MHz 0.18 copper CMOS. L1:
32KB/32KB (8-way). L2: 256 KB (2-way).
• Integrado: ATI Flipper (162 MHz) + DSP (81
Mhz, 16 bit) + Embedded Memory.
• Memoria: 24MB ‘1T SRAM’, 16 MB 81 MHz
SDRAM. Video: 2MB Frame Buffer + 1MB
Texture Cache.
XBOX
• La amenaza Microsoft?
• Intel Pentium III (Celeron). 733 MHz. 32bit Intetger y FP. L1: 32 KB/32KB. L2:
128 KB. 133 MHz bus.
• Chipset: NorthBridge + nVidia NV2A +
Sound DSPs + Ethernet.
• Memoria: UMA, 64 MB, 200 MHz DDRSDRAM (6,4 GB/s).
Descargar

Programación de Emuladores