Universidad de Guadalajara

Centro Universitario de Ciencias

Exactas e ingenierías

Datapath de Instrucciones tipo R e I

Por: Sanchez Fregoso Jose Manuel

Maestro: López Arce Delgado Jorge Ernesto

1
Contenido
Introducción ........................................................................................................................................ 3
Tipos de instrucciones de la arquitectura MIPS .............................................................................. 3
SMIPS............................................................................................................................................... 4
Datapath instrucciones tipo R e I .................................................................................................... 8
Objetivo de actividad ........................................................................................................................ 12
Diagrama de diseño....................................................................................................................... 13
Desarrollo de la actividad .................................................................................................................. 13
Parte 1: Modificaciones................................................................................................................. 13
Modificación 1 ........................................................................................................................... 13
Modificación 2: .......................................................................................................................... 15
Parte 2: Nuevos módulos .............................................................................................................. 17
Modulo nuevo 1: Extensión de signo ........................................................................................ 17
Modulo nuevo 2: MUX de instrucción ...................................................................................... 18
Parte 3: Módulos que no cambian ................................................................................................ 19
Módulo 1: Banco de registros ................................................................................................... 19
Módulo 2: MUX_32 ................................................................................................................... 19
Módulo 3: ALU........................................................................................................................... 20
Módulo 4: Memoria .................................................................................................................. 21
Parte 4: Integración de Top Level ................................................................................................. 22
Parte 5: Testbench ........................................................................................................................ 24
Parte 1 ....................................................................................................................................... 24
Parte 2 ....................................................................................................................................... 25
Parte 3 ....................................................................................................................................... 26
Parte 4 ....................................................................................................................................... 27
Parte 5 ....................................................................................................................................... 28
Parte 6 ....................................................................................................................................... 29
Parte 7 ....................................................................................................................................... 29
Parte 8 ....................................................................................................................................... 29
Conclusión ......................................................................................................................................... 30
Referencias Biblíograficas ................................................................................................................. 30

2
Introducción:

Tipos de instrucciones de la arquitectura MIPS

El set de instrucciones de las arquitecturas mips es algo variado ya que se compone
por más de 100 instrucciones una diferente de la otra.

Los tipos de instrucciones de MIPS son:

Instrucciones de carga o transferencia: Como bien se sabe los procesadores

trabajan con información la cual es fundamental para su funcionamiento, por lo tanto
las principales instrucciones son las instrucciones de carga, de guardado

Una operación de carga (load) copia información de un registro a la memoria

principal, cuando una palabra se carga desde la memoria a un registro o se pasa a
la memoria un registro, la memoria involucrada ha de ser múltiplo de 4, lo que se
denomina restricción de alineamiento. Las direcciones que son múltiplo son
denominadas direcciones alineadas, esta restricción hace que el proceso de
hardware sea más rápida y simple, dichas instrucciones pertenecen al tipo I.

Instrucciones aritméticas lógicas: Son las instrucciones del tipo de formato R, y el

número de operandos en esta clase de instrucción, siempre es 3, estos operando
siempre son direcciones de registros, por lo tanto no necesitan interactuar con la
memoria.

Instrucciones de salto condicional: Estas instrucciones son de tipo I, las pruebas de

desigualdad o igualdad son las más habituales, pero también lo son las
instrucciones de menor que, las cuales el set de instrucciones incluye 2 formatos de
estos, que son en tipo R y tipo I, y también lo que son los saltos condicionales de
una estructura tipo if de lenguajes de programación

Instrucciones de comparación: permiten poner 1 o 0 el valor de un registro con el

cumplimiento o no de una condición.

Instrucciones de bifurcación: Se pueden considerar como un salto condicional, la

instrucción obliga a la maquina a seguir un salto. Este tipo de instrucciones es el
tipo de JUMP, es un modo de direccionamiento es pseudo-directo.

3
SMIPS
Los SMIPS es una versión del conjunto de instrucciones de MIPS, su nombre viene
de MIPS simples, y no es más que un subconjunto del conjunto tipo ISA de MIPS.
El CPU de SMIPS implementa un subcircuito del conjunto de MIPS serie 2, el cual
incluye (todas las operaciones con enteros, excepto instrucciones
multiprocesadores, e instrucciones de carga desalineadas, así como las
instrucciones de retención). Cuenta con 3 registros especiales los cuales 2 de estos
registros son HI y LO que se usan para almacenar los resultados de multiplicaciones
y divisiones de enteros, y el otro registro es para el contador de programa el cual
nos dice cuál será la siguiente instrucción a realizar.

Cuenta con una sola rama la cual es posible humanamente si hay un retraso, y las
cargas no se puede obtener acceso, por lo tanto no es visible un retraso en estas.

Los CPU SMIPS tienen 2 modos operativos, el modo de usuario y el modo de kernel.
El modo operativo el cual se encuentra es almacenado en un KUC bit en el sistema
del coprocesador (COPO) el cual es el status register. EL CPU normalmente trabaja
en modo de usuario hasta que suceda una excepción y se forcé a cambiar a modo
kernel. El CPU en modo kernel normalmente maneja las excepciones, para
proceder a ejecutar el modo de usuario.

Como utilizan en parte las mismas instrucciones solo que uno de forma más
reducida que el otro, se puede realizar un manejador de instrucciones no válidas
para que puedan ser válidas.

EL sistema de control del coprocesador, contiene un número de registros usado

para el manejo de excepciones, el cual se comunica con el procesador central y el
contador de programa/cronometro, estos registros son leído y escritos en base al
estándar del conjunto de instrucciones tipo MIPS, esta es una tabla de los registros
que se usan.

4
Ilustración 1: Tabla de registros de control del coprocesador

Dentro de esta tabla 2 de los registros se comunican de manera frecuente para

sincronizar con lo que se está ejecutando de manera actual, estos registros son el
“fromhost” y “tohost”, que viene siendo desde el principal, y el otro es al principal y
el formato es el siguiente:

Ilustración 2: Formato de instrucciones "fromhost" y "tohost"

También cuenta con un contador y un comparador de registros, el contador viene

ejecutando la función de contador de programa, y registro de comparación solo se
utiliza para realizar pruebas de funcionamiento, ambas instrucciones son de 32 bits
sin ningún formato en especial.

Ilustración 3: Instrucción de cuenta y comparación

5
Los registros de estado, tienen la función de ir siguiendo el funcionamiento del
procesador, sobre qué estado actual se encuentra y a cual cambia, dicho registro
tiene habilitado el modo de lectura o escritura y tiene un formato especial.

Ilustración 4: Instrucción de Registro de estado

CU tiene la función de indicar si el coprocesador se puede usar, y las demás

instrucciones se usan para denotar que nivel de peticiones se está utilizando en el
modo que se está operando, así como las excepciones previas y los estados
anteriores

.También cuenta con un registro de causa, el cual contiene el tipo de la última

excepción que sucedió y este solo está habilitado para lectura. Estas son las
excepciones que valida.

Ilustración 5: Tipos de excepciones

Los SMIPS cuentan con un contador de programa para las excepciones, el cual su
labor es que su ocurre alguna este registro almacena la dirección del registro que la
causo.

Como bien se sabe los SMIPS conserva el mismo conjunto de instrucciones, por lo
tanto, estas no cambian, dentro las instrucciones que pueden utilizar, esta es una
tabla de las instrucciones de tipo SMIPS.

6
Ilustración 6: Lista de instrucciones de SMIPS

7
Ilustración 7: Lista de instrucciones tipo SMIPS

Datapath instrucciones tipo R e I

El datapath que se necesita para le desarrollar las instrucciones tipo R e I, no es
muy distinto del tipo R ya que solo lleva a la integración de más elementos al diseño,
en este caso sería integrar más MUX para las selectivas de instrucción, con esto
me refiero a que las instrucciones tipo I cambian el formato a las instrucciones tipo
R, debido a que solo utilizan 2 operandos y la instrucción inmediata.

Ilustración 8: Instrucción tipo I

8
Ilustración 9: Datapath instrucciones tipo R e I

Como solo logra apreciar el datapath de instrucciones tipo I No cambia a gran escala
solo con la integración de circuitos que su función es analizar el tipo de instrucción
se va a ejecuta, si es de clase R o de tipo I.

Instrucciones tipo I: estas instrucciones son de un tipo especial las cuales se

denominan de orden inmediato, las cuales toman una dirección de la memoria, la
dirección de destino y la operación inmediata.

1. ADDI: Suma inmediata; Opcode: “001 000”

2. ADDIU: Suma inmediata sin signo; Opcode: “001 001”
3. ALUIPC: Suma inmediata a PC; Opcode:”111 011”
4. ANDI: AND lógico inmediato; Opcode: “001 100”
5. AUI: Suma inmediata a bits superiores; Opcode: “001 111”
6. AUIPC: Suma inmediata a bits superiores al PC; Opcode: “111 011”
7. B: Hacer una rama condicional; Opcode: “000 100”
8. BAL: Hacer al PC una proceso de llamada; Opcode: “000 001”
9. BCIEQZ: Hacer un llamado si el coprocesador en un registro es igual a cero;
Opcode: “010 001”
10. BCINEZ: Hacer un llamado si el coprocesador en un registro no es igual a
cero; Opcode: “010 0001”

9
11. BC2EQZ: Hacer un llamado si el coprocesador 2 en un registro es igual a
cero; Opcode: “010 010”
12. BC2NEZ: Hacer un llamado si el coprocesador 2 en un registro no es igual a
cero; Opcode: “010 010”
13. BEQ: Hacer un llamado con el PC si el condicional de un registro es igual;
Opcode: “000 100”
14. BEQL: Comparar con el PC si el condicional es igual, creando un retraso en
la instrucción; Opcode: “010 100”
15. REGIMM: Probar con el PC si una instrucción es mayor o igual a cero;
Opcode: “000 001”
16. BGEZAL: Probar en el PC para hacer un llamado procedural; Opcode: “000
001”
17. BGEZALL: Probar en el PC para hacer un llamado procedural, ejecutando un
retraso; Opcode: “000 001”
18. LB: Cargar un byte de la memoria; Opcode: “100 000”
19. LBU: Cargar un byte de la memoria a un valor sin signo; Opcode: “100 100”
20. LDC1: Cargar una doble palabra de la memoria; Opcode: “110 101”
21. LH: Cargar la mitad de una palabra de la memoria; Opcode: “100 001”
22. LHU: Cargar la mitad de una palabra sin signo; Opcode: “100 101”
23. LUI: Cargar un constante en mitad de una palabra; Oppcode: “001 111”
24. LW: Cargar una palabra de la memoria; Opcode: “100 011”
25. LWC1: Cargar una palabra de valor decimal de la memoria; Opcode: “110
001”
26. LWC2: Cargar una palabra de valor decimal de la memoria a un
coprocesador; Opcode: “010 010”
27. LWL: Cargar la parte más significativa de una palabra a una dirección vacía;
Opcode: “100 010”
28. LWR: Cargar la parte menos significativa de una palabra a una dirección
vacía; Opcode: “100 110”
29. MTC2: Mover una palabra al segundo coprocesador; Opcode: “010 010”

10
30. MTHC2: Mover una palabra a la parte superior de un registro del segundo
coprocesador; Opcode: “010 010”
31. NAL: No operación en una instrucción con retraso; Opcode:”000 001”
32. ORI: OR lógico inmediato; Opcode: “001 101”
33. SB: Almacenar byte en la memoria; opcode: “101 000”
34. SDC1: Guardar una palabra con doble ancho de palabra a la memoria;
Opcode: “111 101”
35. SH: Guardar media palabra; Opcode: “101 001”
36. SLTI: Menor que de forma inmediata; Opcode: “001 010”
37. SLTUI: Menor que sin signa de forma inmediata; Opcode: “001 011”
38. SW: Guardar palabra en la memoria; Opcode: “101 011”
39. SWC1: Guardar palabra con punto decimal en la memoria; Opcode: “111
001”
40. SWL: Guardar la parte más significante de la palabra en una parte de la
memoria; Opcode: “101 010”
41. SWR: Guardar la parte menos significativa de la palabra en una parte de la
memoria; Opcode: “101 110”
42. SYNCI: Sincroniza la memoria cache para que una instrucción de escritura
se haga de forma correcta; Opcode: “000 001”
43. TEQI: Compara si un valor del registro es igual al valor ingresado y checa un
condicional; Opcode: “000 001”
44. TGEIU: Compara una dirección es mayor o igual a un valor de forma
inmediato; Opcode: “000 001”
45. TLTI: Compara si un registro es menor que; Opcode: “000 001”
46. TLTIU: Compara si un registro es menor que, sin signo; Opcode: “000 001”
47. TNEI: Compara si un valor de un registro, no es igual; Opcode: “000 001”
48. XORI: OR exclusivo lógico de forma inmediata; Opcode: “001 110”
49. Como ya se sabe algunas instrucciones pueden tener el mismo Opcode, pero
estas depende de la dirección de la memoria, para que se le interprete un
significado.

11
Objetivo de actividad:

Desarrollar un DATAPATH el cual cumpla con las Instrucciones de tipo R de la

actividad anterior, con un agregado de las instrucciones de tipo I.

Dicho datapath estará conformado por la estructura anterior la cual, solo se le

implementaran unas modificaciones las cuales son 2 MUX adicionales y Un
extensor de signo, a la vez que implementaremos el uso de la memoria tipo cache
para realizar instrucciones como guardar información o cargar información de la
memora a al banco de registros.

Estas son las instrucciones de tipo I que usaremos, además de las instrucciones
tipo R que usamos anteriormente:

Instrucción OP Función ALU

LW 100 011 N/A 000 0
SW 101 011 N/A 000 1
ADDI 001 000 N/A 001 0
ANDI 001 100 N/A 001 1
ORI 001 101 N/A 010 0

12
Diagrama de diseño:

Ilustración 10:Diagrama de diseño

Desarrollo de la actividad:

Parte 1: Modificaciones
Como bien se sabe ahora necesitamos realizar más operaciones para poder
desarrollar la actividad, así que algunas de estas operaciones solo hacen que
modifiquemos el tipo de instrucción

Modificación 1:

Necesitamos modificar nuestra unidad de control debido a que son más

instrucciones, y no solo eso 2 de los nuevos componentes a agregar al diseño
(MUX) necesita una señal selectora que va de la unidad de control

13
Ilustración 11: Código Unidad de control

14
Ilustración 12: Continuación de código

Ilustración 13: Parte final del código

Modificación 2:
Una vez modificada la unidad de control, procedemos a modificar el módulo de que
controla la ALU.

15
Ilustración 14: Código de ALU control

16
Ilustración 15: Código de ALU control

Esto serian todas la modificaciones que son necesarias, si se pregunta porque solo
agregamos solo 3 casos más y tenemos que hacer 5 cosas nuevas diferentes, esto
es debido a que de las nuevas instrucciones necesitan realizar la operación de la
suma ya sea para agregar un valor o acceder a una dirección

Parte 2: Nuevos módulos

Para esta actividad aparecen nuevos módulos, los cuales son el caso de un par de
MUX y un extensor de signo, en este caso solo hablaremos de el MUX nuevo, ya
que 2 de los MUX que usa nuestro diseño ya se habían implementado y es cuestión
de instanciar uno nuevo más.

Modulo nuevo 1: Extensión de signo

El módulo de extensión de signo, nos sirve para expandir el ancho de palabra que
entra como dato de entrada en otro ancho de palabra en base a nuestras
necesidades, en este caso de 16 bits a 32 bits, pero debe cumplir la función que en
base al bit más significativo todos los demás bits que son agregados deben tener el
valor de dicho bit.

17
Ilustración 16: Código de Extensión de signo

Modulo nuevo 2: MUX de instrucción

Necesitamos crear un MUX para la realización de las instrucciones tipo I, debido a
que estas cambian en su formato.

Ilustración 17: Código de MUX de instrucción

En teoría el default nuca debería acceder ya que cubrimos todos los posibles casos,
pero por si las dudas…

Con estos módulos, completaríamos con la integración los nuevos módulos a

necesitar

18
Parte 3: Módulos que no cambian
Una vez explicado los cambios, y los nuevos módulos, procederíamos a la
integración de todos, pero antes los modulo que no sufrieron ninguna alteración y
necesitaremos

Módulo 1: Banco de registros

Ilustración 18: Código Banco de registros

Módulo 2: MUX_32

Ilustración 19: Código MUX 32 bits

19
Módulo 3: ALU

Ilustración 20: ALU modificada

Ilustración 21: Continuación de la ALU modificada

20
Ilustración 22: Final de la modificación de la ALU

Módulo 4: Memoria

Ilustración 23: Código Memoria Asíncrona

Estos son todos los módulos necesarios, para la integración de todo el diseño

21
Parte 4: Integración de Top Level

Ilustración 24: Código de TopLevel

22
Ilustración 25: Código de TopLevel

Ilustración 26: Código de TopLevel

Una vez finalizado, compilamos, corregimos los posibles error que se lleguen a
presentar de sintaxis, procedemos a la visualización de nuestro modulo, solo para
conceptualizar que cumple con el diseño pedido.

23
Ilustración 27: Visualización de diseño

Entonces ya nos queda más que proceder a realizar el testbench para corroborar
sus correcto funcionamiento, en el caso de que no sea así, nos permitirá también el
localizar que conexión o componente no está haciendo lo que debe hacer

Parte 5: Testbench
En esta parte evaluaremos nuestro modulo.

Aquí irían capturas de el testbench, el código, si es que hubiera un test bench jajaja

Parte 1:

Primero tenemos que llenar el banco de registros con sumas inmediatas y un valor
cargado en el banco, en este caso un 1.Con esto rellenaremos 5 posiciones del
banco.

24
Ilustración 28: Testbench de banco de registro

Y esta la parte de código:

Ilustración 29: Código del testbench

Parte 2:
Ahora guardaremos estos resultados en la memoria con la instrucción SW, y utilizando un Base
Pointer en la dirección 11.

25
Ilustración 30: Testbench de memoria

Y su código es:

Ilustración 31: Codigo de testbenc

Parte 3:
Hacemos unas sumas

26
Ilustración 32: Testbech haciendo sumas en el banco

Su codigo:

Ilustración 33: Código de las sumas

Parte 4:
Guardamos los resultados

27
Ilustración 34: Testbench de memoria

Se cambiaron los datos, su código:

Ilustración 35: Código guardando en memoria

NOTA:A partir de este punto ya no se demuestran pruebas debido a que le pique a algo que no y
no me alcanza el tiempo, se puede considerar como fallo en ese punto. Para que lo considere a la
hora de revisión.

Parte 5:
Hacemos ANDI

Código:

28
Ilustración 36: Código de ANDI

Parte 6:
Hacemos ORI, código:

Ilustración 37: Código de ORI

Parte 7:
Cargamos el banco con lo que está en la memoria, código:

Ilustración 38: Código para cargar datos al banco

Parte 8:
Hacemos unas restas y eso es tocho morocho, código:

29
Ilustración 39: Código Restas

Conclusión:

El diseño en si lógico no es complejo una vez teniendo al experiencia de haber

realizado alguno, lo malo es que por cuestiones de no organizar bien mis tiempos
no pude cumplir con los requerimientos en el testbench, en base a las pocas
pruebas que tengo, realiza la suma inmediata sin problemas, por lo tanto estoy
seguro que también hará la ANDI y ORI sin problemas, y las instrucciones tipo R,
no presentaron una dificultad alguna, solo me queda en cuestionamiento el
almacenado en memoria y el cargado de datos. Olvídelo si funciona, había escrito
esto por si no lograba hacer el testbench funcionar correctamente

Referencias Biblíograficas
-. (2005). SMIPS Processor Specification. -: -.

D., P. (2014). Computer Organization and Desing. USA: Morgan Kaufman.

M., J. (2002). VERILOG Quickstart. BOSTON: KLUWER ACADEMIC

PUBLISHERS.

Mano, M. M. (1982). Lógica digital y Diseño de Computadores. Los Angeles:

Prentice Hall.

Pulido, J. A. ( 2000). REPERTORIO DE INSTRUCCIONES MIPS. España:

Universidad de Extremadura.

30
31