%
% Dise~o del simulador MIPS R2000
% Jos'e Luis Guzm'an Sanchez
% Febrero 2000
% 

\documentclass
%[12pt]
[a4paper]
%[twocolumn]
%{report}
{article}
\usepackage{epsfig}
\usepackage[spanish,activeacute]{babel}
\setlength{\hoffset}{-1cm}
\setlength{\textwidth}{14.5cm}
\setlength{\voffset}{-1.5cm}
\setlength{\textheight}{23cm}

\title{Una Simulaci\'on del Procesador {\sl MIPS R2000}}
\author{Jos\'e Luis Guzm\'an Sanchez\\
Estudiante de Ingenier\'{\i}a T\'ecnica de Inform\'atica de Sistemas\\
Universidad de Almer\'{\i}a\\
e-mail: {\tt jguzman@alboran.ualm.es}}
\date{}

\begin{document}
\maketitle
\newpage
\section{Introducci'on} En esta pr'actica lo que he tratado de hacer 
ha sido simular el procesador MIPS R2000 de Silicon Graphics. La 
informacion para el desarrollo de la misma la he obtenido dellibro 
{\it Organizaci'on y Dise~no de Computadores} de Patterson y Hennessy.
Ciertamente la parte que yo he desarrollado ha sido la Unidad de control 
principal, los multiplexores de 32 bits, la Unidad de control de la ALU,
la ALU con anticipaci'on de arrastre y el ensamblamiento de todos los 
componentes. Adem'as he dise~nado una peque~na interfaz con el usuario en
modo terminal, en la cual el usuario podr'a realizar diferentes operaciones 
durante la simulaci'on. A continuaci'on ire explicando como he ido 
desarrollando las diferentes partes y como las he ensamblado.

\section{Dise~no de la ALU con anticipaci'on de arrastre}
En realidad el dise~no de la ALU en si es el mismo que ten'iamos de la 
biblioteca SLCD++, y lo que yo he mejorado ha sido obtener los bits de
acarreo de forma anticipada, de forma que a la hora de obtener el resultado
no tenemos que ir calculando de forma secuencial los acarreos como se hacia
en la ALU normal. A esta ALU mejorada se le denomina {\sl ALU con
anticipaci'on de arrastre}. Para calcular los acarreos he utilizado las
siguientes ecuaciones:\\
\begin{displaymath} g^{}_{i}=a^{}_{i} b^{}_{i}
\end{displaymath}
\begin{displaymath}
p^{}_{i}=a^{}_{i}+b^{}_{i}
\end{displaymath}
\\
Donde $g^{}_{i}$ o {\sl generaci'on} ser'a activo si el bit i del sumador 
genera un CarryOut independiente del CarryIn; y $p^{}_{i}$ o {\sl 
propagaci'on} que se activar'a cuando el bit i del sumador propaga un 
CarryIn a un CarryOut. Los bits $a^{}_{i}$ y $b^{}_{i}$ hacen referencia a
los bits de los operandos.\\
\\
Una vez calculados los bits de generaci'on y propagaci'on para calcular los 
bits de acarreo habr'a que aplicar estas otras ecuaciones:\\
\begin{displaymath} carry0=g^{}_{0}+(p^{}_{0} c^{}_{0})
\end{displaymath}
\begin{displaymath}
carry1=g^{}_{1}+(p^{}_{1} g^{}_{0})+(p^{}_{1} p^{}_{0} c^{}_{0})
\end{displaymath}
\begin{displaymath} 
carry2=g^{}_{2}+(p^{}_{2} g^{}_{1})+(p^{}_{2} p^{}_{1} g^{}_{0})+
(p^{}_{2} p^{}_{1} p^{}_{0} c^{}_{0})
\end{displaymath}
\begin{displaymath} 
carry3=g^{}_{3}+(p^{}_{3} g^{}_{2})+(p^{}_{3} p^{}_{2} g^{}_{1})+
(p^{}_{3} p^{}_{2} p^{}_{1} g^{}_{0})+
(p^{}_{3} p^{}_{2} p^{}_{1} p^{}_{0} c^{}_{0})
\end{displaymath}
\begin{displaymath} 
\ldots
\end{displaymath}
\\
As'i sucesivamente hasta calcular los 31 acarreos. Una vez calculados 
bastar'a con pasarle los acarreos a la ALU normal reduciendo as'i los ciclos
de duraci'on de la misma. 
\\
La implementaci'on de la funci'on que calcula los acarreos se encuentra en 
el archivo {\sl alu32.cc} y se denomina {\sl Carryin}.

\section{Dise~no de la Unidad de Control de la ALU}
La implementaci'on de esta UC es muy sencilla y consiste en 2 puertas
AND, 3 NOR y 2 NOT, las cuales y encadenadas de la forma en la que est'an 
en la gr'afica, tras recibir los 6 'ultimos bits de la operaci'on ( para
las R-format ) y los bits ALUOPs de la UC principal generan la secuencia 
de 3 bits correspondiente para indicar a la ALU la funci'on a realizar.
La implementaci'on de dicha UC se encuentra en los archivos {\sl uc\_alu.* }.

\begin{figure}
 \centering
 \epsfig{file=ucalu.eps, width=10cm}
 \caption{Implementaci'on de la UC de la ALU}
 \label{fig:ucalu}
\end{figure}

\section{Dise~no de los Multiplexores de 32 bits}
Nosotros ten'iamos multiplexores y multiplexores en la biblioteca SLCD++,
pero dichos multiplexores trabajaban con buses de tama~no de 1 bit. Por
ello y como nuestros buses son de 32 bits, tuve que ampliar dichos 
multiplexores. Para dicha ampliaci'on en el caso de los multiplexores
de 2 a 1 simplemente tomo los buses de 32 bits y realizo bit a bit la 
selecci'on, es decir, hago un bucle de 32 iteraciones el cual tendr'a en 
su interior un multiplexor de 2 a 1 de 1 bit, y en cada iteraci'on ire 
tomando bit a bit de los buses y realizando la selecci'on previamente dicha.
Una vez realizados los multiplexores de 2 a 1, la implementaci'on de los 
multiplexores de 4 a 1 es inmediata, encadenando 3 multiplexores de 2 a 1
ya adaptados a 32 bits.
\\
La implementaci'on de dichos multiplexores se encuentra en los archivos
{\sl muxs.*}.

\section{Dise~no de la Unidad de Control Principal}
La UC principal en realidad es una m'aquina de estados finitos, la cual
tras conocer el c'odigo de una determinada instrucci'on va pasando por una
serie de estados y generando un conjunto de l'ineas de control que 
permitiran poder realizar la ejecuci'on de la instrucci'on recibida.
Para la implementaci'on de esta m'aquina de estados finitos, pod'iamos 
elegir dos caminos diferentes:

\begin{enumerate}
\item Implementarla a trav'es de una aut'omata.
\item Implementarla con una {sl PLA( Programmed Logic Array)}
\end{enumerate}
Bien, yo me he decido por la segunda. Su implementaci'on es como queda 
mostrada en la siguiente figura:

\begin{figure}
 \centering
 \epsfig{file=pla.eps, width=10cm}
 \caption{Simulaci'on del MIPS R2000}
 \label{fig:pla}
\end{figure}

De forma que para obtener el resultado de una l'inea de control hay que 
ver las l'ineas verticales a las que hace referencia ( se~naladas con puntos).
Una vez obtenidas, se har'a la operaci'on AND de los valores de cada l'inea
vertical; y la obtenci'on del valor final vendr'a dado por la operaci'on OR
de los valores obtenidos.
\\
Los componentes que forman esta PLA son 54 AND, 10 NOT y 11 OR. Pero para 
la construcci'on completa de la UC principal hace falta tambi'en un registro
de 4 bits que ira guaradando el estado generado. La conexi'on de la PLA con
dicho registro es como sigue a continuaci'on:

\begin{figure}
 \centering
 \epsfig{file=uc.eps, width=10cm}
 \caption{Simulaci'on del MIPS R2000}
 \label{fig:uc}
\end{figure}

Adem'as de los expuesto en el gr'afico, para poder considrar cuando llega
el final de programa lo que he hecho ha sido introducir una nueva 
instrucci'on "end", la cual se intentificar'a por tener los 6 bits del 
c'odigo operaci'on todos a 1, y una nueva l'inea de control denominada con
el mismo nombre, la cual solo se activar'a cuando el estado sea el n'umero
10 ( un nuevo estado introducido para esta instrucci'on ).
La implementaci'on de todo ello se encuentra en los archivos {sl uc.* }.

\section{Conjunto de todos los componentes}
Los componenetes utilizados para la implementaci'on del camino de datos son
los siguientes:
\begin{enumerate}
\item 4 registros de 32 bits.
\item 1 fichero de registros de 32 x 32.
\item 6 puertas AND.
\item 1 puerta OR.
\item 1 UC de la ALU.
\item 1 ALU de 32 bits con anticipaci'on de arrastre.
\item 1 UC principal.
\item El conjunto de todas l'ineas de control y buses de datos necesarios
para la conexi'on de todos estos componentes. 
\end{enumerate}
La declaraci'on de todos estos componentes as'i como las l'ineas de control
se encuentra en el archivo {sl micro.h} . Adem'as de todos los componentes
que forman el camino de datos en si, tambi'en utilizo una memoria de 64x32.

\section{Dise~no del camino de datos multiciclo}
Una vez definidos y declarados todos los componentes la conexi'on de todos 
ellos es realizada de forma secuencial. A la hora de la implementaci'on he
pretendido llevar el orden aproximado del dibujo de la pag. 287 (del libro 
que estamos siguiendo) de izquierda a derecha, de forma que los pasos que 
sigo son los siguientes:
\begin{enumerate}
\item Calculo las l'ineas de control llamando a la UC principal con los bits
correspondientes de la operaci'on.
\item Determinaci'on de escritura o lectura del PC.
\item Selecci'on de direcci'on para el acceso a memoria.
\item Acceso al fichero de instrucci'on.
\item Acceso al fichero de registros, con la selecci'on previa en los 
multiplexores.
\item Selecci'on de los operandos de la ALU.
\item Determinaci'on de escritura o lectura en registro Target.
\item Selecci'on de direcci'on siguiente.
\end{enumerate}
Una vez implementado el camino de datos, lo que hago es comunicarlo con la 
memoria, de forma que voy leyendo un conjunto de instrucciones previamente
cargadas, las cuales trabajar'an con un conjunto de datos que tambi'en 
previamente cargados en memoria. Lo que hago en realidad es introducir el 
camino de datos en un bucle semi-infinito, hasta que se encuentre la 
instrucci'on {sl end}. Una representaci'on gr'afica de dicha simulaci'on es
la siguiente:

\begin{figure}
 \centering
 \epsfig{file=todo.eps,width=10cm}
 \caption{Simulaci'on del MIPS R2000}
 \label{fig:todo}
\end{figure}

\section{Peque~na Interfaz}
El simulador ha sido dotado con una peque~na interfaz con el usuario en modo
terminal, la cual nos permite poder llevar la simulaci'on paso a paso, ver
el contendio de cualquier linea de control o bus de datos, ejecutar el
programa hasta el final, interrumpir la simulaci'on etc...Adem'as dicha 
interfaz nos ira mostrando continuamente la instrucci'on en curso, y al 
final de la simulaci'on nos mostrar'a  el contenido integro de la memoria.
\\
Para poder ver los diferentes comando teclear "help".

\section{Carja de un programa y ejecuci'on de la simulaci'on}
Para poder ejecutar un programa en el simulador bastar'a con escribirlo en
lenguaje ensamblador en un archivo denominado {sl prog}, y los datos a
utilizar en un archivo denominado info.s, donde primero se indicar'a el
numero de datos a introducir y posteriormente se introducir'an los datos.
Para la ejecuci'on bastar'a con teclear {sl script.}

\section{Caracter'isticas del procesador}
Para el correcto funcionamiento del simulador, me ha sido necesario poner un
ciclo de reloj de 22 iteraciones. Bien pues considerando que cada iteraci'on
tarda unos 0.9ns, el procesador que estoy simulando tendr'ia una frecuencia de
reloj de unos 50 Mhz.
\end{document}