\documentstyle[spanish]{article}
\begin{document}
\Large
%\thispagestyle{smpty}
\centerline{\bf SIMULACION DEL R2000}
\normalsize
\bigskip
\bigskip
\noindent{\large\bf Introducci\'on}
\bigskip
\newline 
En esta pr\'actica simulamos el funcionamiento del microprocesador MIPS R2000 de Silicon Graphics. Toda la informaci\'on se ha sacado del libro \textit{Organizaci\'on y Dise~no de Computadores} de John L. Hennessy y David A. Patterson.
\bigskip
\newline
Concretamente mi simulaci\'on se corresponde al microprocesador \textbf{multiciclo}.
\bigskip
\newline
\noindent{\large\bf Caracter\'isticas del sistema}
\bigskip
\newline
El simulador que se presenta a continuaci\'on dispone de una peque�a interfaz interactiva con el usuario que atiende a necesidades m\'as comunes del usuario con el programa, aunque tambi\'en su funcionamiento puede ser totalmente comprobado con el depurador de linux GDB. 
\bigskip
\newline
El programa se carga en el fichero Programa.asm en ensamblador y los datos se cargan en el fichero Datos.asm, tambi\'en en ensamblador. La memoria principal es de 64 direcciones por 32 bits de datos por direcci\'on. Desde la posici\'on 0 hasta la posici\'on 31 se utiliza para cargar las instrucciones, mientras que desde la posici\'on 32 hasta la 64 se utiliza para los datos.
\bigskip
\newline
La memoria se podia haber partido de otra forma, yo lo he hecho as\'i por comodidad.
\bigskip
\bigskip
\newline
\noindent{\large\bf Funcionamiento de mi programa}
\bigskip
\newline
Para hacer funcionar la simulaci\'on , tan solo debemos de escribir el programa en el fichero PROGRAMA.asm y los datos que va a utilizar el programa en el fichero DATOS.asm. Tan solo en el fichero DATOS.asm tendremos que indicar el n\'umero de datos que vamos a utilizar al principio del programa.
\bigskip
\newline
A continuaci\'on se debe de ejecutar el \textit{script ejecuta}, y autom\'aticamente el simulador arrancar\'a. En el terminal que el simulador nos ofrece, podemos poner la orden help, la cual nos indicar\'a lo que se podr\'a hacer con el simulador.
\newpage
\noindent{\large\bf Memoria sobre la pr\'actica}
\bigskip
\newline 
Como hemos dicho anteriormente, lo que se ha construido es un simulador del microprocesador R2000 multiciclo. Para llegar a esta simulaci\'on se ha necesitado tiempo y esfuerzo.
\bigskip
\newline
Lo primero que hice ante todo fue analizar el problema, aunque hay que reconocer que esto no es nada f\'acil. En primer lugar tuve que coger el libro de Organizaci\'on y dise~no de Computadores (olvidado tiempo atr\'as), y volver a repasar algo que ya estudie en mi tiempo. 
\bigskip
\newline
Pasado el tiempo tiempo ya me acordaba de su funcionamiento e integraci\'on, pero el paso dificil quedaba por llegar. A continuaci\'on cre\'i conveniente recolectar todos los componentes que durante el curso me habian dado (memorias, registros, and, or, etc) y saber de lo que disponia, de forma que  me fu\'i al esquema que queria implementar (multiciclo) y comprob\'e los componentes que ten\'ia y los que me hacian falta. No muchos eran los componentes, pero entre ellos destac\'o tan solo la \textit{Unidad de Control}, y me puse a construirla. 
\bigskip
\newline
Una vez construida la unidad de control, y dem\'as componentes (muxes, extensor de signo, etc) me v\'i obligado a montar el procesador. Para ello segu\'i la misma filosofia que sigue el libro de Patterson y Hennessy. Primeramente se debe de actualizar el estado en el que el procesador se encuentra para su posterior procesamiento de los datos. En segundo lugar, y una vez que conocemos el estado del procesador, debemos de actualizar todas las l\'ineas de los componentes y sus correspondientes estados, y por \'ultimo escribimos la secuencia de ejecuci\'on, tal cual como Patterson y Hennessy la describen, empezando por el PC, siguiendo por el multiplexor siguientes, y finalizando por la ALU. Tal vez la filosofia que se ha empleado en este \'ultimo punto se puede alterar, pero yo lo he visto m\'as f\'acil de esta manera. 
\bigskip
\newline
Y de esta manera apareci\'o el simulador MIPSR2000. La implementaci\'on del mismo se ha realizado en C++ con objetos, obteniendo as\'i  una clase del MIPSR2000, o sea, con esta clase puedo declarar tantos procesador como a m\'i me hagan falta dentro de alg\'un programa, y sin problemas en cuanto al reparto de la memoria entre sus variables. Esta implementaci\'on se puede ver dentro del fichero MIPSR2000.cc y MIPSR2000.h.
\bigskip
\bigskip
\newline
\noindent{\large\bf Construcci\'on de nuevos componentes.}
\bigskip
\newline
En esta parte vamos a hablar de los componentes que he tenido que construir para poder implementar el multiciclo. Pocos son estos y entre ellos destacamos la Unidad de Control. Para construirla me he basado en la PLA que viene en el ap\'endice C p\'agina 693. Una vez que hemos hecho la PLA (f\'acil de realizar) debemos de interconectarla con un regsitro que va a ser el que va a contener el estado siguiente que la PLA a calculado a trev\'es del estado de entrada y que va a valer para que ejecuci\'on de las instrucciones sea parecida al diagrama de la p\'agina 683. El esquema final implementado es el que viene en la p\'agina 684 y se puede ver la implementaci\'on total en el fichero UCM.cc y UCM.h, el registro utilizado es s\'incrono, por ello que utilizamos la entrada de reloj.
\bigskip
\newline
Otro componente m\'as que se ha implementado es la unidad de control de la ALU que viene reflejada en la Figura 5.18 de la p\'agina 256, que se utilizar\'ia para indicar a la ALU las operaciones que debe de realizar. Esta implementaci\'on es f\'acil de realizar y tan solo se debe de utilizar gates.h y defs.h para su implementaci\'on, y lo podemos ver en el fichero control\_ALU.cc y control\_ALU.h, donde se ha incorporado una peque~na comprobaci\'on del c\'odigo.
\bigskip
\newline
Otros componentes m\'as que se han creado pero no con mucha dificultad, son los multiplexores que componen parte del multiciclo. Para ello se han creado las clases MUX\_2\_1\_32b, MUX\_2\_1\_5b y MUX\_4\_1\_32b reutilizando clases anteriormente creadas. La implementaci\'on se pueden ver en los fichero muxs.h y muxs.cc. Otro componente m\'as que podemos destacar es el extensor de signo de 16 bits, f\'acil de hacer y que se encuentra dentro del fichero Ext\_Signo16b.h y Ext\_Signo16b.cc. 
\bigskip
\bigskip
\newline
\noindent{\large\bf Anomal\'ias durante la construcci\'on.}
\bigskip
\newline
Una vez que tuve todos los componentes implementados, la fase de implementaci\'on comenzo. Los primero paso eran lentos y comprobando todo, pero conforme la implementaci\'on crec\'ia tambi\'en lo hac\'ia con ella el diseno. Durante este periodo muchos son los errores que he cometido, pero tambi\'en otros tantos los fallos que he descubierto. Entre ellos destaca el registro \$0 de la memoria de registros. Forzosamente este registro debe de estar a 0 siempre (seg\'un la norma MIPS), pero esto no ocurr\'ia. El fallo casi seguro se encuentra en la propia implentaci\'on de la memoria de registros. No me he parado en verlo, pero lo soluciono escribiendo el 0 en el constructor de la clase MIPSR2000.
\bigskip
\newline
Otro problema que tuve fue durante la fase de pruebas, donde la instrucci\'on sw no funcionaba correctamente al no escribir el valor adecuado dentro de la memoria. Esto se llegu\'o a solucionar interconectando una puerta AND entre el reloj, su entrada de control de escritura y la se�al de control de escritura que proviene de la unidad de control.
\bigskip
\newline
Como nuestra memoria es de posiciones contiguas se ha suprimido en la implementaci\'on los desplazamientos de 2 bits.
\bigskip
\newline
\noindent{\large\bf El fichero SIMULACION.cc.}
\bigskip
\newline
Una vez que tenenemos todo bien planteado y contruida la clase MIPSR2000, necesitamos interactuar de alguna forma esta con el resto de los componentes importantes como son la memoria y el reloj. Esto precisamente se realiza en el fichero SIMULACION.cc. Dentro de un bucle hacemos que el procesador se comunica con el reloj del sistema y con la memoria que va a contener las instrucciones y los datos necesarios para esas instrucciones. Cada ciclo que realiza el bucle sobre estos componentes es lo que denominamos iteracci\'on, y un ciclo de reloj va ha estar compuesto por varias iteracciones del programa. Pero no solamente en este fichero hacemos esto que es lo m\'as importante. Tambi\'en realizamos la carga de las instrucciones y datos en la memoria que vamos a utilizar dentro de la simulaci\'on.  
\bigskip
\bigskip
\newline
\noindent{\large\bf La instrucci\'on END.}
\bigskip
\newline
Cuando al principio empez\'e a ejecutar la simulaci\'on, ten\'ia que contar con previo aviso, el n\'umero de iteracciones que necesitaba el programa que se iba a ejecutar. Al principio de todo cuando estaba depurando la simulaci\'on esto no me parec\'ia engorroso, pero con el tiempo si lo fu\'e. De esta necesidad surgi\'o la instrucci\'on END. La instrucci\'on END es una instrucci\'on inventada por m\'i y que he incluido en el repertorio de instrucciones para cuando el programa acabe de ejecutarse, una patilla de la unidad de control se active y me indique la finalizaci\'on de este. Para instroduccir esta instrucci\'on dentro del repertorio he tenido que modificar la unidad de control y sus correspondientes tablas que se incluyen en el ap\'endice C. Para incluir esta instrucci\'on dentro de un programa, tan solo debemos de a�adir al final de la secuencia de ejecuci\'on end. Un ejemplo claro es el programa ejemplo que muestro con el simulador.
\bigskip
\bigskip
\newline
\noindent{\large\bf La interfaz del simulador.}
\bigskip
\newline
Es una interfaz sencilla y suficiente como para que un usuario pueda sacar del simulador lo m\'inimo e imprescindible. No era objetivo de esta asignatura realizar una buena interfaz pero si es aconsejable hacerla para el simulador. La interfaz es interactiva e incluye una informaci\'on sobre las instrucciones que lleva, con tan solo poner help en el terminal. En cualquier momento puedes salidar del programa y al final de la ejecuci\'on del mismo, mostramos la memoria de datos (para comprobar resultados) junto con los ciclos de reloj e iteracciones que se han consumido. La implementaci\'on la podemos encontrar dentro del fichero SIMULACION.cc, y pasamos como par\'ametro el objeto micro. Esto lo podemos hacer gracias a unas de las propiedades que tiene el lenguaje O.O. que es poder hacer amiga (friends) a una funci\'on determinada dentro de una clase, y podiendo acceder a las variables privadas del mismo. Con esta propiedad nos evitamos tener que pasar bastantes par\'ametros y dar un gran valor de independencia a la clase MIPSR2000. 
\bigskip
\bigskip
\newline
\noindent{\large\bf El script Ejecuta.}
\bigskip
\newline
A la hora de ejecutar el simulador debemos de poner ./ejecuta. Este fichero es un script que contiene;
\bigskip
\newline
./asm programa.asm prog.txt
\newline
./filtro prog.txt>programa.txt
\newline
./asm\_datos>datos.txt
\newline
./test\_SIMUL
\bigskip
\newline
En primer lugar asm es un fichero ejecutable que se obtiene a trav�s del fichero asm2r2k.c (un poco modificado del que nos distes). Este programa permite pasar un programa en ensamblador a c\'odigo m\'aquina y que este se refleje en el archivo prog.txt. Este archivo lo tomar\' un segundo ejecutable que se llama filtro y lo que va ha hacer es poner el fichero prog.txt de manera que a nosotros nos venga bien. El resultado se descarga en el fichero programa.txt. El fichero ejecutable asm\_datos, lo que hace es pasar los datos de ensamblador y que se encuentran en el fichero datos.asm a c\'odigo m\'aquina. Este ejecutable lo he realizado yo y se encuentra en el fichero asm\_datos.c. Pos \'ultimo ejecutamos el simulador que viene por el ejecutable test\_SIMUL. Este script nos centraliza m\'as el funcionamiento del simulador.
\bigskip
\bigskip
\newline
\noindent{\large\bf Planeamiento de posibles mejoras.}
\bigskip
\newline
Son muchas la mejoras que se pueden hacer pero entre ellas destaco la incorporaci\'on de una memoria cach\'e y una mejora en la ALU con anticipaci\'on de arrastre. Otro posible planteamiento ser\'ia la construcci\'on del procesador segmentado, y posr supuesto y debido a la grandes caracter\'isticas que nos brinda la programaci\'on orientada a objetos, ser\'ia la construcci\'on de un programa que nos simulara el procesamiento en paralelo de dos procesadores, y por que no de n-procesadores.  
\bigskip
\bigskip
\newline
\noindent {\bf Jos\'e Antonio Gil Rosa}
3� ITIS.

\end{document}
 












