post.html

<h1 id="como-escribir-un-emulador-de-computadora-traducción-al-español">Como escribir un emulador de computadora [traducción al español]</h1>
<p>Traducción al español de &quot;Como escribir un emulador de computadora&quot; por Marat Fayzullin</p>
<p>Escribí este documento luego de recibir varios correos electrónicos de personas a las que les gustaría escribir un emulador de una u otra computadora, pero que no saben por donde empezar. Las opiniones y consejos contenidos en este articulo son únicamente mios y no deberían ser tomados como verdad absoluta. El documento trata principalmente sobre los llamados emuladores &quot;interpretes&quot;, contrario a los &quot;compiladores&quot;, pues no tengo mucha experiencia con técnicas de recompilación. Se proporcionan un par de enlences donde se puede encontrar información sobre estas técnicas.</p>
<p>Si considera que hace falta algo en este documento, o desea hacer una corrección, siéntase libre de enviarme un email con sus comentarios. <strong>NO</strong> respondo sin embargo a idioteces o solicitudes de imágenes ROM. Si conoce enlaces que pudiesen ser útiles aquí avíseme, lo mismo aplica para preguntas frecuentes que no se encuentran en el documento.</p>
<p>Este documento ha sido traducido al Japonés por Bero. También hay traducciones al Chino, cortesía de Shun-Yuan Chou, otra traducción al Chino por Jean-Yuan Chen. La traducción al Francés por Maxime Vernier. La nueva traducción al español por Daniel Campoverde [Alx741], y finalmente la traducción al Portugués de Brazil por Leandro.</p>
<h2 id="contenidos">Contenidos</h2>
<p>Así que decidió escribir un emulador?, muy bien, en ese caso este documento podría ayudarle. Cubre algunas preguntas técnicas que las personas se preguntan sobre el tema. También provee algunas muestras sobre el el diseño interno de los emuladores que podría usar para guiarse en cierta medida.</p>
<h2 id="general">General</h2>
<ul>
<li>Qué puede ser emulado?</li>
<li>Qué es un &quot;emulador&quot; y en que se diferencia de un &quot;simulador&quot;?</li>
<li>Es legal emular hardware propietario?</li>
<li>Qué es un emulador &quot;interpretador&quot; y por que es diferente de uno &quot;recompilador&quot;?</li>
<li>Quiero escribir un emulador. Por dónde debo empezar?</li>
<li>Qué lenguaje de programación debería usar?</li>
<li>Dónde puedo obtener información del hardware a emular?</li>
</ul>
<h2 id="implementación">Implementación</h2>
<ul>
<li>Cómo emular una CPU?</li>
<li>Cómo manejo el acceso a la memoria emulada?</li>
<li>Tareas cíclicas: qué son?</li>
</ul>
<h2 id="técnicas-de-programación">Técnicas de programación</h2>
<ul>
<li>Cómo optimizo código C?</li>
<li>Qué es low/high-endiness?</li>
<li>Cómo hacer un programa portable?</li>
</ul>
<h2 id="qué-puede-ser-emulado">Qué puede ser emulado?</h2>
<p>Básicamente, todo aquello que tiene un microprocesador dentro. Desde luego, solamente dispositivos ejecutando programas más o menos flexibles son interesantes de emular. Estos incluyen:</p>
<ul>
<li>Computadoras</li>
<li>Calculadoras</li>
<li>Consolas de vídeo juegos</li>
<li>Vídeo juegos de Arcade</li>
<li>etc.</li>
</ul>
<p>Es necesario notar que se puede emular <strong>cualquier</strong> sistema de computo, incluso si es muy complejo (como por ejemplo una computadora Commodore Amiga). Aunque el rendimiento será muy bajo.</p>
<h2 id="qué-es-un-emulador-y-en-que-se-diferencia-de-un-simulador">Qué es un &quot;emulador&quot; y en que se diferencia de un &quot;simulador&quot;?</h2>
<p>La emulación es el intento de imitar el diseño interno de un dispositivo. Simulación es un intento por imitar las funciones del dispositivo. Por ejemplo: un programa imitando el hardware de Pacman árcade y ejecutando una ROM real de Pacman es un emulador. Un juego de Pacman escrito para su computadora, pero usando gráficos similares a los del juego de árcade real, es un simulador.</p>
<h2 id="es-legal-emular-hardware-propietario">Es legal emular hardware propietario?</h2>
<p>Aunque este tema está en el &quot;área gris&quot;, aparentemente es legar emular hardware propietario, siempre y cuando la información sobre este no haya sido obtenida por medios ilegales. Debería también estar consiente de que es ilegal distribuir ROM's de sistemas (BIOS, etc.) con un emulador, si estos están bajo copyright.</p>
<h2 id="qué-es-un-emulador-interpretador-y-por-que-es-diferente-de-uno-recompilador">Qué es un emulador &quot;interpretador&quot; y por que es diferente de uno &quot;recompilador&quot;?</h2>
<p>Existen tres esquemas básicos usados para diseñar un emulador. Pueden también ser combinados para obtener mejores resultados.</p>
<ul>
<li>Interpretación</li>
</ul>
<p>El emulador lee el código emulado byte por byte, lo decodifica, y realiza los comandos adecuando en los registros emulados, memoria y I/O. El algoritmo general es el síguete:</p>
<pre><code>    while(CPUIsRunning)
    {
        Fetch OpCode
        Interpret OpCode
    }</code></pre>
<p>Las virtudes de este modelo incluyen la facilidad para depurar, portabilidad y facilidad de sincronización (se puede simplemente contar ciclos de reloj y enlazar el resto de la emulación a este conteo).</p>
<p>La única y gran debilidad es el bajo rendimiento. La interpretación toma mucho tiempo de CPU y será necesaria una computadora veloz para ejecutar el código a una velocidad decente.</p>
<ul>
<li>Recompilación estática</li>
</ul>
<p>En esta técnica, se toma el programa emulado y se intenta traducirlo al código assembly de la computadora emuladora. El resultado generalmente será un ejecutable que se puede usar directamente en la computadora sin ninguna herramienta especial. Mientras que la recompilación estática suena muy bien, no siempre es posible. Por ejemplo: no se puede usar con código auto modificado (mutable) pues no existe forma de saber en que se convertirá al ejecutarlo. Para evitar estas situaciones, se puede intentar combinar esta técnica con un interprete o un recompilador dinámico.</p>
<ul>
<li>Recompilación dinámica</li>
</ul>
<p>La recompilación dinámica es esencialmente lo mismo que la estática, pero ocurre durante la ejecución el programa. En lugar de intentar recompilar todo el código a la vez, se realiza sobre la marcha cuando se encuentra una instrucción CALL o JUMP. Para incrementar la velocidad, esta técnica puede ser combinada con la recompilación estática. Se puede leer más sobre esta técnica en el <a href="http://www.ardi.com/MacHack/machack.html">Documento de Ardi</a>, creadores de el emulador recompilador de Macintosh.</p>
<h2 id="quiero-escribir-un-emulador.-por-dónde-debo-empezar">Quiero escribir un emulador. Por dónde debo empezar?</h2>
<p>Para escribir un emulador, se debe tener un buen conocimiento general sobre programación y electrónica. Tener algo de experiencia con assembly es útil también.</p>
<ol style="list-style-type: decimal">
<li><a href="http://fms.komkon.org/EMUL8/HOWTO.html#LABF">Seleccionar un lenguaje de programación</a></li>
<li><a href="http://fms.komkon.org/EMUL8/HOWTO.html#LABG">Encontrar información sobre el hardware a emular</a></li>
<li><a href="http://fms.komkon.org/EMUL8/HOWTO.html#LABH">Escribir u obtener un emulador de la CPU</a></li>
<li>Escribir código de prueba para emular el resto del hardware, al menos parcialmente.</li>
<li>En este punto, es útil escribir un pequeño depurador sobre el mismo emulador, de forma que permita detener la emulación y observar que está haciendo el programa. Se podría necesitar un desensamblador del sistema emulado o escribir uno si no existe.</li>
<li>Intentar ejecutar programas en el emulador.</li>
<li>Usar un desensamblador y depurador para ver como el programa usa el hardware y ajustar el código apropiadamente.</li>
</ol>
<h2 id="qué-lenguaje-de-programación-debería-usar">Qué lenguaje de programación debería usar?</h2>
<p>Las alternativas más evidentes son C y Assembly. Aquí algunos pros y contras de cada uno:</p>
<ul>
<li><p>Assembly</p></li>
<li>Generalmente, produce código más veloz.</li>
<li>Los registros de la CPU emuladora se puede usar directamente para almacenar registros de la CPU emulada.</li>
<li>Varios opcodes pueden ser emulados con opcodes similares de la CPU emuladora.</li>
<li>El código no es portable, no se puede ejecutar en una computadora con distinta arquitectura.</li>
<li><p>Es mas difícil de depurar y mantener.</p></li>
<li><p>C</p></li>
<li>El código puede hacerse portable</li>
<li>Es relativamente sencillo depurar y mantener</li>
<li>Diferentes hipótesis de como funciona el hardware real se puede hacer rapidamente</li>
<li><p>C es mas lento que assembly puro.</p></li>
</ul>
<p>Un buen conocimiento sobre el lenguaje elegido es necesario para escribir un emulador funcional, es un proyecto complejo y el código debe ser optimizado para funcionar lo más veloz posible. La emulación de computadoras <em>NO</em> es un proyecto con el cual se aprende un nuevo lenguaje de programación</p>
<h2 id="dónde-puedo-obtener-información-del-hardware-a-emular">Dónde puedo obtener información del hardware a emular?</h2>
<p>Aquí hay una lista de lugares para revisar:</p>
<ul>
<li><p>Grupos usenet</p>
<ul>
<li>comp.emulators.misc</li>
<li>comp.emulators.game-consoles</li>
<li>comp.sys./emulated-system/</li>
<li>rec.games.video.classic</li>
</ul></li>
<li><p>FTP</p></li>
</ul>
<p><a href="ftp://x2ftp.oulu.fi/">Programación de consolas y juegos</a> <a href="ftp://ftp.spies.com/">Hardware de juegos de Arcade</a> <a href="ftp://ftp.komkon.org/pub/EMUL8/">Historia de la computación y emulación</a></p>
<ul>
<li>WWW</li>
</ul>
<p><a href="http://www.komkon.org/fms/">Pagina de Marat</a> <a href="http://valhalla.ph.tn.tudelft.nl/emul8/arcade.html">Repositorio de emulación de Arcade</a> <a href="http://www.classicgaming.com/EPR/">Recuso de programadores de emulación</a></p>
<h2 id="cómo-emular-una-cpu">Cómo emular una CPU?</h2>
<p>Primeramente, si solamente necesita emular una CPU estandar Z80 o 6502, puede usar uno de los <a href="http://www.komkon.org/fms/EMUL8/">emuladores que eh escrito</a>. Aunque ciertas condiciones aplican.</p>
<p>Para aquellos que desean escribir sus propios emuladores de CPU, proveo abajo el esqueleto de un emulador típico en C. En un emulador real, se debería saltar y agregar las partes que se desea.</p>
<pre><code>    Counter=InterruptPeriod;
    PC=InitialPC;

    for(;;)
    {
        OpCode=Memory[PC++];
        Counter-=Cycles[OpCode];

        switch(OpCode)
        {
            case OpCode1:
            case OpCode2:
                ...
        }

        if(Counter&lt;=0)
        {
            /* Check for interrupts and do other */
            /* cyclic tasks here                 */
            ...
                Counter+=InterruptPeriod;
            if(ExitRequired) break;
        }
    }</code></pre>
<p>Primero asignamos los valores iniciales a contador <code>counter</code> de ciclos de la CPU, y el contador de programa <code>PC</code>:</p>
<pre><code>    Counter=InterruptPeriod;
    PC=InitialPC;</code></pre>
<p><code>Counter</code> contiene el numero de ciclos de CPU que quedan hasta la siguiente interrupción. Nótese que la interrupción no debería necesariamente ocurrir cuando el contador expira, se puede usar para varios otros propósitos, como sincronización de temporizadores, o actualizar la pantalla. Más sobre esto luego. El <code>PC</code> contiene la dirección de memoria desde la que la CPU emulada leerá el siguiente opcode.</p>
<p>Luego de que los valores iniciales fueron asignados, se inicial el loop principal:</p>
<pre><code>    for(;;)
    {</code></pre>
<p>Nótese que este loop también se puede implementar como:</p>
<pre><code>    while(CPUIsRunning)
    {</code></pre>
<p>Donde <code>CPUIsRunning</code> es una variable booleana. Esto tiene ventajas, pues se puede terminar el loop en cualquier momento con <code>CPUIsRunning=0</code>. Desafortunadamente, revisar esta variable en cada pasada requiere tiempo de CPU, y debería ser evitado de ser posible.</p>
<p>Además <strong>no</strong> implemente el loop así:</p>
<pre><code>    while(1)
    {</code></pre>
<p>Porque en este caso algunos compiladores generarán código para revisar si <code>1</code> es true o false. Ciertamente no quiere que el compilador haga trabajo innecesario en cada pasada del loop.</p>
<p>Ahora, cuando estamos en el loop, lo primero es leer el siguiente opcode y modificar el contador de programa:</p>
<pre><code>    OpCode=Memory[PC++];</code></pre>
<p>Nótese que mientras esta es la forma más simple y rapida de leer la memoria emulada, <strong>no siempre es la mejor</strong>. Una forma más universal de acceder la memoria se presenta más adelante en este documento.</p>
<p>Luego de que se obtiene el opcode, se decrementa el contador de ciclos de la CPU. <strong>Tome en cuenta</strong> que algunos opcodes (como los saltos condicionales o llamadas a subrutinas) pueden tomar distintos números de ciclos, dependiendo de los argumentos. Esto se puede ajustar luego en el código.</p>
<p>Ahora es momento de interpretar el opcode y ejecutarlo:</p>
<pre><code>    switch(OpCode)
    {</code></pre>
<p>Es un error común pensar que <code>switch()</code> es ineficiente, pues se compila como <code>if() ... else if() ...</code>. Mientras que esto es verdad par aun pequeño numero de casos, un <code>switch()</code> grande (100-200 o más casos) siempre se compila como una tabla de saltos, lo que es más eficiente.</p>
<p>Existen dos alternativas para interpretar opcodes. La primera es hacer una tabla de funciones y llamar a la apropiada. La segunda es hacer una tabla de etiquetas, y usar <code>goto</code>. Mientra que este método es un poco más veloz que un <code>switch()</code>, solamente funcionará en compiladores que soporten &quot;etiquetas pre computadas&quot;. Otros compiladores no le permitirán crear un array de etiquetas.</p>
<p>Luego de una interpretación exitosa de un opcode, es necesario revisar si son necesarias interrupciones. En este momento se puede realizar cualquier tarea que necesite ser sincronizada con el reloj del sistema.</p>
<pre><code>    if(Counter&lt;=0)
    {
        /* Revisar interrupciones y hacer otras emulaciones aquí */
        ...
        Counter+=InterruptPeriod;
        if(ExitRequired) break;
    }</code></pre>
<p>Estas tareas cíclicas se cubren luego en el documento.</p>
<p>Nótese que no asignamos simplemente <code>Counter=InterruptPeriod</code>, pero hacemos <code>Counter+=InterruptPeriod</code>, esto hace el conteo más preciso, pues pueden haber algunos números negativos de ciclos en <code>Counter</code>.</p>
<p>También observe:</p>
<pre><code>    if(ExitRequired) break;</code></pre>
<p>Como es muy costoso revisar una salida en cada pasada del loop, solo lo hacemos cuando <code>Counter</code> expira, así saldremos de la emulación cuando <code>ExitRequired=1</code>, y no tomará mucho tiempo de CPU.</p>
<h2 id="cómo-manejo-el-acceso-a-la-memoria-emulada">Cómo manejo el acceso a la memoria emulada?</h2>
<p>La forma más simple de acceder a la memoria emulada es tratarla como un array de bytes (palabras, etc.). Acceder es entonces trivial:</p>
<pre><code>    Data=Memory[Address1]; /* Leer de Address1 */
    Memory[Address2]=Data; /* Escribir en Address2  */</code></pre>
<p>Un acceso tan simple no siempre es posible por algunas razones:</p>
<ul>
<li><p>Memoria paginada</p>
<p>La dirección de memoria puede ser fragmentada en paginas intercambiables (bancos). Esto se hace para expandir la memoria direccionable.</p></li>
<li><p>Memoria reflejada</p></li>
</ul>
<p>Un área de memoria puede ser accedida desde diferentes direcciones.</p>
<ul>
<li><p>Protección de ROM</p>
<p>Algunos programas basados en cartuchos intenta escribir en la ROM y se reusa a funcionar si tiene exito al hacerlo. Esto se hace por proteccion de copia.</p></li>
<li><p>I/O mapeada en memoria</p>
<p>Pueden existir dispositivos I/O mapeados en memoria en el sistema. Acceder a esas posiciones de memoria produce efectos especiales y deben ser rastreados.</p></li>
</ul>
<p>Para solucionar estos problemas, se introducen unas funciones:</p>
<pre><code>    Data=ReadMemory(Address1);  /* Leer de Address1 */
    WriteMemory(Address2,Data); /* Escribir en Address2  */</code></pre>
<p>Todo el procesamiento especial como paginas de acceso, espejos, I/O, etc. Se realiza en estas funciones.</p>
<p><code>ReadMemory()</code> y <code>WriteMemory</code> usualmente causan mucha sobrecarga en la emulación, pues se invoca con mucha frecuencia. Y por tanto, deben ser lo más eficientes posible. Aquí hay un ejemplo para acceder a memoria paginada:</p>
<pre><code>    static inline byte ReadMemory(register word Address)
    {
        return(MemoryPage[Address&gt;&gt;13][Address&amp;0x1FFF]);
    }

    static inline void WriteMemory(register word Address,register byte Value)
    {
        MemoryPage[Address&gt;&gt;13][Address&amp;0x1FFF]=Value;
    }</code></pre>
<p>Nótese el <code>inline</code>. Esto causará que el compilador coloque el código directamente, en lugar de hacer llamadas a la función. Si el compilador no lo soporta, intente hacer la función <code>static</code>. Algunos compiladores (como WatcomC) optimizarán funciones estáticas pequeñas haciéndolas <code>inline</code>.</p>
<p>También tenga en mente que en muchos casos <code>ReadMemory()</code> es llamada muchas veces y con más frecuencia que <code>WriteMemory()</code>. Por lo tanto es importante implementar la mayor parte del código en <code>WriteMemory()</code>, dejando <code>ReadMemory()</code> pequeña.</p>
<ul>
<li>Una nota sobre la memoria reflejada:</li>
</ul>
<p>Como lo dicho anteriormente, muchas computadoras tienen RAM reflejada donde un valor escrito en una posición aparecerá en otras. Mientras que esta situación puede ser manejada en <code>ReadMemory()</code>, es usualmente no deseable, pues <code>ReadMemory()</code> es llama con mucha más frecuencia que <code>WriteMemory()</code>. Una forma más eficiente es implementar memoria reflejada en <code>WriteMemory()</code>.</p>
<h2 id="tareas-cíclicas-qué-son">Tareas cíclicas: qué son?</h2>
<p>Las tareas ciclicas son cosas que deben ocurrir periodicamente en la maquina, como:</p>
<ul>
<li>Refrescar la pantalla</li>
<li>Interrupciones VBlank y HBlank</li>
<li>Actualizar temporizadores</li>
<li>Actualizar parámetros de sonido</li>
<li>Actualizar estado de joysticks/teclados</li>
<li>etc.</li>
</ul>
<p>Para emular estas tareas, se debe mantenerlas unidas a un cierto numero de ciclos de CPU. Por ejemplo: si la CPU corre a 2.5MHz y la pantalla usa una frecuencia de refrescamiento de 50Hz (vídeo PAL estándar), la interrupción VBlank debe ocurrir cada</p>
<pre><code>    2500000/50 = 50000 ciclos de CPU</code></pre>
<p>Ahora, si se asume que la pantalla completa (incluyendo VBlank) es 256 lineas de alto y 212 de ellas son mostradas en la pantalla (otras 44 caen en VBlank), debemos hacer que el emulador refresque la pantalla cada</p>
<pre><code>    50000/256 ~= 195 ciclos de CPU</code></pre>
<p>Luego de eso, se debe generar la interrupción VBlank y no hacer nada hasta terminar VBlank, por</p>
<pre><code>    (256-212)*50000/256 = 44*50000/256 ~= 8594 ciclos de CPU</code></pre>
<p>Calcular con cuidado los ciclos de CPU necesarios para cada tarea, y usar el <strong>maximo común divisor</strong> para <code>InterruptPeriod</code> y atar todas las tareas a este (no se deben ejecutar necesariamente cada expiración de <code>Counter</code>).</p>
<h2 id="cómo-optimizo-código-c">Cómo optimizo código C?</h2>
<p>Primeramente, mucha de la eficiencia se puede lograr eligiendo las opciones de optimización del compilador. Basado en mi experiencia, seguir la combinación de opciones nos dará las mejores velocidades de ejecución:</p>
<pre><code>    Watcom C++      -oneatx -zp4 -5r -fp3
    GNU C++         -O3 -fomit-frame-pointer
    Borland C++</code></pre>
<p>Si encuentra mejores opciones para estos compiladores, porfavor, déjeme saber.</p>
<ul>
<li>Sobre los loop unrolling</li>
</ul>
<p>Puede parecer útil usar la opción &quot;loop unrolling&quot; del optimizador. Esta opción intentará convertir los pequeños en piezas de código lineal. Mi experiencia muestra sin embargo que esta opción no produce mejoras en la eficiencia. Activarla puede también dañar su código en casos especiales.</p>
<p>Optimizar código C es algo mas complicado que elegir las opciones del compilador, y generalmente depende de la CPU para la que se compila. Varias reglas generales aplican para todas las CPUs. No las tome como reglas absolutas, todo puede variar:</p>
<ul>
<li>Use el profiler!</li>
</ul>
<p>Ejecutar el programa con un profiler (GPROF viene a mi mente) puede revelar muchas cosas que jamas sospecharía. Encontrará que piezas insignificantes de código se ejecutan mucho mas frecuentemente que el resto y ralentizan todo el programa. Reescribir estas en assembly puede mejorar el programa.</p>
<ul>
<li>Evite C++</li>
</ul>
<p>Evite usar construcciones que lo fuercen a compilar su programa con un compilador de C++, use C plano. Compiladores C++ usualmente añaden más sobrecarga al código.</p>
<ul>
<li>Tamaño de los enteros</li>
</ul>
<p>Procure usar solamente enteros de la base del tamaño soportado por la CPU como <code>int</code> en lugar de <code>short</code> o <code>long</code>. Esto reduce el tamaño del código que el compilador genera para convertir entre diferentes longitudes de enteros. También puede reducir los tiempos de acceso a memoria, pues algunas CPUs trabajan más rápido cuando leen/escriben datos basados en el tamaño alineado al tamaño de los limites de direcciones.</p>
<ul>
<li>Asignación de registro</li>
</ul>
<p>Use tan pocas variables como sea posible en cada bloque y declare las más frecuentes como <code>register</code>. Esto tiene más sentido para CPUs con muchos registros de propósito general (PowerPC) que en los que tienen registros dedicados (Intel 80x86).</p>
<ul>
<li>Desenvolver loops pequeños</li>
</ul>
<p>Si tiene loops pequeños que se ejecutan pocas veces, es buena idea desenvolverlos manualmente en código lineal.</p>
<ul>
<li>Desplazamiento vs multiplicación/división</li>
</ul>
<p>Siempre use desplazamientos cuando necesite multiplicar o dividir para potencias de 2^n (J/128==J&gt;&gt;7). Se ejecutan mas rápido. También use <code>AND</code> para obtener el modulo (J%128==J&amp;0x7F).</p>
<h2 id="qué-es-lowhigh-endiness">Qué es low/high-endiness?</h2>
<p>Todas las CPU's se dividen en clases, dependiendo de que como almacenen los datos en memoria. Mientras que hay algunas muy peculiares, la mayoría caen en dos clases:</p>
<ul>
<li>High-endian</li>
</ul>
<p>Almacenan los datos de forma que los bytes más altos de la palabra siempre aparece primero en la memoria. Por ejemplo, si almacena 0x012345678 la memoria será:</p>
<pre><code>     0  1  2  3
    +--+--+--+--+
    |12|34|56|78|
    +--+--+--+--+</code></pre>
<ul>
<li>Low-endian</li>
</ul>
<p>Almacenan los datos de forma que los bytes más bajos de la palabra siempre aparece primero en la memoria. Por ejemplo, si almacena 0x012345678 la memoria será:</p>
<pre><code>     0  1  2  3
    +--+--+--+--+
    |12|34|56|78|
    +--+--+--+--+</code></pre>
<p>Ejemplos típicos de CPUs high-endian son 6809, Motorola 680x0, PowerPC, Sun SPARC. CPUs low-endian como 6502 y sucesores 65816, Zilog Z80, la mayoria de los chips Intel (8080, 80x86), DEC Alpha, etc.</p>
<p>Cuando se escribe un emulador, se debe estar consiente de el endianess de la CPU emulada así como de la emuladora. Digamos que quiere emular un Z80 (low-endian). Esto es, Z80 almacena sus palabras de 16 bites con el byte bajo primero. Si quiere usar una CPU low-endian como Intel 80x86 para esto, todo ocurre de forma natural. Pero si quiere usar una CPU high-endian como PowerPC, de repente hay un problema al colocar los datos de 16 bits en la memoria. Icluso peor si su programa debe funcionar en ambas arquitecturas, necesitará alguna forma de conocer el endiness.</p>
<p>Una forma de manejar el problema del endiness es:</p>
<pre><code>    typedef union
    {

        short W;        /* Acceso a palabra */

        struct          /* Acceso a byte... */
        {
    #ifdef LOW_ENDIAN
            byte l,h;     /* ...en arquitectura low-endian */
    #else
            byte h,l;     /* ...en arquitectura high-endian */
    #endif
        } B;

    } word;</code></pre>
<p>Como puede ver, una palabra puede ser accedida usando <code>W</code>. Cada vez que la emulación necesite acceder como byte separados deberá usar <code>B.l</code> y <code>B.h</code> lo que preserva el orden.</p>
<p>Si su programa será compilado para varias plataformas, usted querrá probar que fue compilado con la opción correcta de endiness antes de ejecutar algo importante. Aquí hay una forma de probarlo:</p>
<pre><code>    int *T;

    T=(int *)&quot;\01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0&quot;;
    if(*T==1) printf(&quot;Esta maquina es high-endian.\n&quot;);
    else      printf(&quot;Esta maquina es low-endian.\n&quot;);</code></pre>
<h2 id="cómo-hacer-un-programa-portable">Cómo hacer un programa portable?</h2>
<p><em>Por ser escrito...</em></p>
<h2 id="por-qué-debería-hacer-un-programa-modular">Por qué debería hacer un programa modular?</h2>
<p>La mayoría de los sistemas de computo son echos a partir de grandes chips, los cuales realizan ciertas tareas del sistema. Así existe una CPU, un controlador de vídeo, un generador de sonido, etc. Algunos de estos chips pueden tener su propia memoria y otro hardware.</p>
<p>Un emulador típico debería repetir el diseño del sistema original implementando cada subsistema en un modulo separado. Esto hace la depuración más sencilla, pues todos los bugs se localizan en los módulos. Ademas, la arquitectura modular permite reusar módulos en otros emuladores. El hardware de computadora está bastante estandarizado, puede esperar encontrar la misma CPU o chip de vídeo en muchos modelos de computadoras. Es mas fácil emular el chip una vez que implementarlo una y otra vez para cada computadora usando ese chip.</p>