Estudio de las técnicas de diseño e implementación de emuladores

1. 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

2. 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.

3. 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.

4. 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

5. ¿Qué es un emulador? • Emulador = programa software que intenta reproducir el funcionamiento de una computadora (origen) en otra computadora (destino). Reproducir MÁQUINA DESTINO MÁQUINA ORIGEN Convertir Traducir

6. 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.

7. 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.

8. 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.

9. 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).

10. 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).

11. 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.

12. Algoritmo básico while (!end) { emularCPU(); emularGraficos(); emularSonido(); controlTiempo(); }

13. 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.

14. 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).

15. 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.

16. Instrucción • Esquema básico de la ejecución una instrucción: obtenerOperandos() realizarOperacion() guardarResultado() actualizarCiclosEjecutados()

17. 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.

18. 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).

19. Ensamblador • Codificar las instrucciones o todo el emulador en ensamblador para: • Aprovechar mejor las capacidades de la CPU destino (flags). • Implementar más eficientemente el bucle principal (fetch-decode). Se puede poner inlined al final de la instrucción.

20. Traducción Binaria • Dos métodos: • Traducción Binaria Estática. • Traducción Binaria Dinámica.

21. 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.

22. 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.

23. 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.

24. 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.

25. 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.

26. 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.

27. 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.

28. Palabra a almacenar: 0x12345678 0x12 0x34 0x56 0x78 0x78 0x56 0x34 0x12 Palabra almacenada en formato Big-Endian 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.

29. 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.

30. Palabra a almacenar: 0x12345678 0x78 0x56 0x34 0x12 0x12 0x34 0x56 0x78 Palabra almacenada en formato Big-Endian Palabra almacenada en formato Little-Endian Ejemplo endianismo

31. 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.

32. 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.

33. 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.

34. 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.

35. Layers layers pantalla Prioridades Ordenación

36. Ejemplo de sistema basado en Tiles Background (tiles) Sprites

37. Ejemplo de sistema basado en Sprites/Tiles Los dos layers (tiles y sprites) se combinan para formar la imagen

38. 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.

39. Framebuffer framebuffer gráfico blit

40. 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.

41. 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.

42. 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.

43. 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.

44. 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.

45. 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)

46. 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).

47. Vídeo Consolas Z80, VDP, PSG 6502, PSG, VDP, ROMs Master System NES Turbo Graph 685c2, VDP + FX, DSP M68000, VDP, FM SNES Genesis 2xM68000, SH2, VDP + FX, FM, PCM MegaCD/32X 2xSH2, M68000, VDP, 3D, DSP Saturn MIPS R4300, RCP, RDRAM PSX N64 MIPS R3000, GTE SH4, ARM7, NEC VR2 EE (MIPS, VPU1, VPU2), RDRAM Dreamcast PS2 Gekko (PPC 750), Flipper (ATI) GameCube PIII 733, NVIDIA NV17, UMA XBOX

48. 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)

49. 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).

50. 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).