Universidad de Guadalajara

Centro Universitario de Ciencias

Exactas e ingenierías

Datapath de Instrucciones tipo R

Por: Sanchez Fregoso Jose Manuel

Maestro: López Arce Delgado Jorge Ernesto

1
Tabla de contenido
Introducción ........................................................................................................................................ 3
¿Qué es un datapath? ..................................................................................................................... 3
Tipos de instrucción R ..................................................................................................................... 4
Objetivo de la actividad:...................................................................................................................... 7
Diagrama de diseño: ....................................................................................................................... 8
Desarrollo de actividad: ...................................................................................................................... 8
Parte 1: modificaciones. .................................................................................................................. 8
Modificación 1 ............................................................................................................................. 8
Modificación 2 ............................................................................................................................. 9
Parte 2: Módulos nuevos .............................................................................................................. 10
Módulo 1 ................................................................................................................................... 10
Módulo 2 ................................................................................................................................... 11
Módulo 3 ................................................................................................................................... 12
Parte 3: Módulos que no cambiaron ............................................................................................ 13
Parte 4: Integración del top level .................................................................................................. 13
Parte 5: test bench ........................................................................................................................ 15
Conclusión ......................................................................................................................................... 17
Referencias Bibliograficas ................................................................................................................. 17

2
Introducción:

¿Qué es un datapath?
Se refiere la integración a un nivel más alto de los componentes para el crear un conjunto
el cual referencia todo el proceso, el cual es generado por el procesador, de forma más
simplificada es el trayecto de la información para realizar las operaciones que deseamos,
no es más que una sub-red interconectada.

Para la integración de un datapath es crítico lo que se debe hacer, es decir para que función
se quiere desarrollar dicho diseño, debido a que depende de esto para el nivel de
abstracción sobre la instrucción , para el desarrollo de esta actividad nos enfocaremos en
desarrollar instrucciones tipo R.

Para la ejecución de instrucciones tipo R sobre una arquitectura tipo MIPS es necesario,
(saltando los ciclos fetch y la memoria de instrucciones) un banco de registros, una ALU,
una Memoria Tipo cache, una Unidad de control, una unidad de control sobre la ALU, un
MUX, y nuestra instrucción.

Como las instrucciones tipo R son aritméticas- lógicas, todas se desarrollaran en la ALU, por
lo tanto es de forma fundamental su funcionamiento. Y la otra parte fundamental de esto,
es el banco de registros. Esto es debido a que las instrucciones de tipo de R contienen 3
operados, de los cuales 2 son posiciones de lectura de nuestro banco de registros, y el
tercero es la dirección de destino, claro está que no es ese orden.

3
Ilustración 1: Datapath para instrucciones tipo R

La composición de una instrucción tipo R es la siguiente:

Código de
operación rs bits rt bits rd shamt Función
bits [25:21] [20:16] bits[15:11] bits[10:6] bits[5:0]
[31:26]

donde el código de operación se utiliza para determinar que tipo es, en este caso
una tipo R.
rs es la primer dirección de lectura
rt es la segunda dirección de lectura
rd es la dirección de destino, (dirección para la escritura)
shamt no lo utilizaremos
función es que operación de tipo R queremos realizar(suma, resta, división, entre
otras)

Tipos de instrucción R
Como bien sabemos las instrucciones tipo R realizan tarea aritméticas y lógicas

4
Estas son las instrucciones tipo R, cabe recordad que todas las instrucciones tipo R tienen
un Opcode “000 000”

1. ADD: Suma o Añadir palabra; función: “100 000”

2. ADDU: Suma sin signo; función: “100 001”
3. AND: “Y” lógica; función: “100 100”
4. BREAK: Un breakpoint, punto de paro; función: “001 101”
5. CLO: cuenta de bits significativos; función: “010 001”
6. CLZ: cuenta de los bits significativos en ceros; función: “010 000”
7. DDIV: División de doble palabra; función: “011 110”
8. DDIVU: División de doble palabra sin signo; función: “011 111”
9. DIV: División; función: “011 010”;
10. DIV/ MOD: División entre modulo; función: “011 010”
11. DIVU: División sin signo; función: “011 011”
12. EHB: Ejecución de barrera de amenazas, Detiene toda instrucción hasta que se tome
medidas contra la “amenaza”; función: “000 000”
13. JALR: Salto a la dirección del registro, sirve para llamados de instrucciones en un
registro; función: “001 001”
14. JALR.HB: Salto a una dirección con una barrera de amenaza; función: “001 001”
15. JR: Salto de registro, se usa para dar saltos en los registros de instrucciones; función:
“001 001”
16. JR.HB: Salto de registro con barrera de amenazas, da saltos en el registro de
instrucciones; función: “001 001”
17. LSA: Cargar en dirección escalada; función: “000 101”
18. MFHI: Mover de registro HI a normal; función: “010 000”
19. MFLO: Mover de registro LO a normal; función: “01 010”
20. MOVF: Mover condicional en punto decimal falso; “000 001”
21. MOVN: Mover condicional en un No cero; función: “001 011”
22. MOVT: Mover condicional en punto decimal verdadero; función: “000 001”
23. MOVZ: Mover condicional en Zero; función: “001 010”

5
24. MTHI: Mover un registro normal a HI; función: “010 001”
25. MTLO: Mover un registro normal a LO; función: “010 011”
26. MULT: Multiplicar; función: “011 000”
27. MULTU: Multiplicar sin signo; función: “011 001”
28. NOP: No operación; función: “000 000”
29. NOR: NOR lógica; función: “100 111”
30. OR: OR lógica; función: “100 101”
31. PAUSE: Espera por el LLBit por limpiar; función: “000 000”
32. ROTR: Rota la palabra a la derecha; función: “000 010”
33. ROTRV: Rota la palabra a la derecha una cantidad variable de bits; función: “000
110”
34. SLL: Cambia la palabra a la izquierda lógica; función: “000 000”
35. SLLV: Cambia la palabra a la izquierda lógica una cantidad variable de bits; función:
“000 100”
36. SLT: Comparativa menor que; función: “101 010”;
37. SLTU: Comparativa menor que sin signo; función: “101 011”;
38. SRA: Cambia la palabra a derecha, le da un giro; función: “000 011”
39. SRAV: Cambia la palabra a derecha una cantidad variable de bits, le da un giro;
función: “000 111”
40. SRL: Cambia la palabra a la derecha lógicamente; función: “000 010”
41. SRLV: Cambia la palabra a la derecha lógicamente una cantidad variable de bits;
función: “000 110”
42. SUB: resta; función: “100 010”
43. SUBU: Resta sin signo; función: “100 011”
44. SYSCALL: Llamar al sistema para una excepción; función: “001 100”
45. TEQ: Detiene una instrucción si son iguales; función: “110 100”
46. TGE: Detiene una instrucción si es mayor o igual; función: “110 000”
47. TGEU: Detiene una instrucción si es mayor o igual sin signo; función: “110 001”
48. TLT: Detiene una instrucción si es menor que; función: “110 010”

6
 49. TLT: Detiene una instrucción si es menor que sin signo; función: “110 011”
50. TNE: Detiene la instrucción si no es igual; función: “110 110”
51. XOR: OR exclusiva lógica; función: “100 110”

Estas son la gran mayoría de las instrucciones de MIPS32 bits, cabe aclarar que como se
sabe la arquitectura utiliza un sistema basado en memorias las cuales se les asigna una
posición con un valor la cual tiene un significado dependiendo de la dirección en la cual se
está usando, solo para aclarar las funciones repetidas, es ese el porqué.

Objetivo de la actividad:
El objetivo de la actividad es desarrollar un datapath para que cumpla con las instrucciones
tipo R que vamos a designar de arquitectura tipo MIPS, nuestro diseño se compondrán de
un banco de registros, una memoria, una ALU, una Unidad de control, una ALU control y un
multiplexor.

Instrucciones que usaremos son:

Instrucción OP Función ALU

suma 000 000 100 000 000 0

Resta 000 000 100 011 000 1

Multiplicación 000 000 011 000 001 0

División 000 000 011 010 001 1

AND 000 000 100 100 010 0

OR 000 000 100 101 010 1

XOR 000 000 100 110 011 0

NOR 000 000 100 111 011 1

SLT 000 000 101 011 100 0

7
Diagrama de diseño:

Desarrollo de actividad:
Parte 1: modificaciones.
Debido a que el datapath es la integración a una escala de las actividades anteriores;
necesitamos el modificar unos módulos para lograr la actividad.

Modificación 1:

Primero tenemos que modificar la memoria para que cumpla con el diseño.

8
Ilustración 2: Memoria modificada

Modificación 2:

Debido a que haremos más operaciones dentro de nuestra ALU necesitamos el expandir la
cantidad de casos para poder realizar la actividad.

Ilustración 3: ALU modificada

9
Ilustración 4: Continuación de la ALU modificada

Ilustración 5: Final de la modificación de la ALU

Parte 2: Módulos nuevos

En esta parte desarrollaremos los módulos nuevos que necesitamos

Módulo 1:

Debemos crear una unidad de control que es la que se encarga de leer el Opcode de la
instrucción y mandar la señal a los demás módulos, esto es fundamental ya que como su
nombre es la que controla todo

10
Ilustración 6: Unidad de control

Módulo 2:

Una vez creada la Unidad de control, procedemos a crear un bloque que será nuestra
ALU_control el cual, controla en base al tipo de instrucción, que operación debe hacer la
ALU.

11
Ilustración 7: ALU control

Ilustración 8: Continuación de la ALU control

Módulo 3:

12
Por último el modulo es más que un MUX que elige si pasa una instrucción de la memoria o
de la ALU.

Ilustración 9: Modulo de MUX

Parte 3: Módulos que no cambiaron

Uno de los módulos que no cambio es el banco de registros

Ilustración 10: Banco de registros

Parte 4: Integración del top level

Una vez que tenemos todos los componentes necesarios para elaborar el diseño,
procedemos a crearlo, en un módulo, el cual solo tendrá una entrada.

13
Ilustración 11: DATAPATH

Ilustración 12: Continuación de DATAPATH

14
Con eso finalizamos el top level, lo compilamos y una vez copilado para asegurarnos de su
funcionamiento comprobemos usando el sistema de analizador de diseños o el
interconectado de nuestro modulo (netlist)

Ilustración 13: Netlist del DATAPATH

Nuestro diseño debe quedar algo así esto nos permitirá el visualizar que las conexiones son
las correctas debido a que es de suma importancia y cuidado el hacer esto.

Parte 5: test bench

Una vez seguros de que el diseño este bien, procedemos a la ejecución de las instrucciones
en el TB.

Ilustración 14: TB del DATAPATH

Una vez compilado procedemos a visualizar la simulación, visualizamos el banco de registros

para confirmar que nuestro diseño funcione como debe funcionar, y corroboramos que si
lo hace

15
Ilustración 15: Visualizacion del Banco de registros

Observamos el waveform para visualizar las instrucciones, posiblemente no se logran

apreciar debido a los tiempos pero se pude hacer zoom para corroborar

Ilustración 16: Visualización previa de todas las instrucciones realizadas

Ilustración 17: Visualización ampliada de las instrucciones

16
Ilustración 18: Vista general

Conclusión: El desarrollo de la actividad no fue del todo complicado ya que es cuestión

de organizar todo lo necesario desde información, como viene siendo las instrucciones, los
Opcodes, entre otros, la parte más compleja en si fue la interconexión de todos los módulos,
recomiendo el realizar cada conexión de un módulo hasta completarla y seguir con el otro
de forma secuencial, y la otra parte fue en las instrucciones en el testbench debido a que es
complejo el manejar tantos número, pero de ahí en fuera no es tanto trabajo, lo que si veo
complejo para la otra activad el extensor de signo….

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

Lee, W. F. (2003). Verilog Coding for Logic Synthesis. New Jersey: Willey Interscience.

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

MIPS. (2016). MIPS Architecture for Programmers. -: MIPS.

Plantz, R. G. ( 2011). Introduction to Computer Organization . Sonoma State :

bob.cs.sonoma.edu.

17