Programación de Emuladores

Document Sample
Programación de Emuladores Powered By Docstoc
					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    DESTINO

                Traducir
    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 (16-
    bit), Naomi (32-bits).
  – Videoconsolas modernas: Play Station (32-
    bits), 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-execute-
  loop. 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 y destino.
  de la CPU origenalmacenar: 0x12345678
• Little/Big endian.
              0x12       0x34     0x56      0x78
• Realizar laPalabra almacenadaenformato Big-Endian
              conversión en cada acceso:
  costoso.
• Convertir toda la memoria.
                 0x78      0x56      0x34       0x12
              Palabra almacenada en formato Little-
              Endian
              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
                Master System    Z80, VDP, PSG
              6502, PSG, VDP, ROMs
    NES

 SNES        685c2, VDP + FX,Turbo Graph FM
                Genesis      DSP
                           M68000, VDP,
                                2xM68000, SH2,
               MegaCD/32X
                                VDP + FX, FM, PCM
                  Saturn    2xSH2, M68000, VDP,
           MIPS R4300, RCP,      PSX    MIPS R3000, GTE
 N64       RDRAM            3D, DSP
                                                   EE (MIPS, VPU1, VPU2)
                                    SH4, ARM7, NEC VR2
                 Dreamcast               PS2       RDRAM
               Gekko (PPC 750), Flipper 733, NVIDIA
                                    PIII
GameCube       (ATI)
                                                     XBOX
                                    NV17, UMA
                             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. 32-
  bit 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 DDR-
  SDRAM (6,4 GB/s).