Arquitectura del computador 2022

# Arquitectura del computador 2022 ## Laboratorio 1 #### Autores: * Clariá Dambolena, Felipe * Piloni, Martin * Echeverria Perpetua, Fabio Santiago #### Tabla de Contenido [TOC] --- ### Ejercicio 1 Este ejercicio está basado en la implementación de un microprocesador ARMv8 con Pipeline, pero en forma reducida. Este microprocesador no realiza manejo de hazards de datos ni de control. #### Código assembler original A continuacion se muestra un codigo de assembler que produce hazard de datos y de control, produciendo un resultado indebido ```s STUR X1, [X0, #0] STUR X2, [X0, #8] STUR X3, [X16, #0] ADD X3, X4, X5 STUR X3, [X0, #24] SUB X3, X4, X5 STUR X3, [X0, #32] SUB X4, XZR, X10 STUR X4, [X0, #40] ADD X4, X3, X4 STUR X4, [X0, #48] SUB X5, X1, X3 STUR X5, [X0, #56] AND X5, X10, XZR STUR X5, [X0, #64] AND X5, X10, X3 STUR X5, [X0, #72] AND X20, X20, X20 STUR X20, [X0, #80] ORR X6, X11, XZR STUR X6, [X0, #88] ORR X6, X11, X3 STUR X6, [X0, #96] LDUR X12, [X0, #0] ADD X7, X12, XZR STUR X7, [X0, #104] STUR X12, [X0, #112] ADD XZR, X13, X14 STUR XZR, [X0, #120] CBZ X0, loop1 STUR X21, [X0, #128] loop1: STUR X21, [X0, #136] ADD X2, XZR, X1 loop2: SUB X2, X2, X1 ADD X24, XZR, X1 STUR X24, [X0, #144] ADD X0, X0, X8 CBZ X2, loop2 STUR X30, [X0, #144] ADD X30, X30, X30 SUB X21, XZR, X21 ADD X30, X30, X20 LDUR X25, [X30, #-8] ADD X30, X30, X30 ADD X30, X30, X16 STUR X25, [X30, #-8] finloop: CBZ XZR, finloop ``` #### Contenido de la memoria al finalizar la ejecución del código original ``` Memoria RAM de Arm: Address Data 0 0000000000000001 1 0000000000000002 2 0000000000000003 3 0000000000000003 4 0000000000000009 5 0000000000000004 6 FFFFFFFFFFFFFFF6 7 0000000000000005 8 0000000000000002 9 0000000000000001 10 0000000000000014 11 0000000000000006 12 000000000000000B 13 0000000000000007 14 0000000000000001 15 0000000000000000 16 0000000000000015 17 0000000000000015 18 000000000000001E 19 000000000000003C 20 0000000000000000 21 0000000000000000 22 0000000000000000 ... 61 0000000000000000 62 0000000000000000 63 0000000000000000 ``` #### Ejecución con presencia de un hazard de datos Veamos la traza de ejecución de la siguiente sección del código, que presenta un hazard de datos: ```s 3> ADD X3, X4, X5 4> STUR X3, [X0, #24] 5> ... ``` ![](https://i.imgur.com/P3OlM6p.png) A los 0.045 ns de la simulación se realiza el Fetch de la instrucción `ADD X3, X4, X5` que se encuentra en la posición 3 de la memoria de instrucciones. Luego, a los 0.055 ns se hace el Fetch de la 4ta instrucción: `STUR X3, [X0, #24]`. Esto ocurre mientras se realiza el Decode de la instrucción anterior. Finalmente, para los 0.065 ns, ocurre el Execute de la instrucción 3 y el Decode de la instrucción 4. Según lo indican las señales `ID_EX_regWrite`, `ID_EX_wa3` y `EXECUTE/aluEesult_E`, la instrucción 3 escribirá el valor *9* en el registro `X3` en la etapa de Writeback. Sin embargo, como se ve según las señales `DECODE/ra2` y `DECODE/readData2_D`, la instrucción 4 ya leyó el valor *3* del mismo registro, produciendo entonces el **hazard de datos**. #### Ejecución con presencia de un hazard de control Analicemos también el siguiente segmento de código, que presenta un hazard de control: ```s 29> CBZ X0, loop1 30> STUR X21, [X0, #128] loop1: 31> STUR X21, [X0, #136] 32> ADD X2, XZR, X1 ``` ![](https://i.imgur.com/Kfezt7O.png) Cuando t = 0.305 ns, se hace el Fetch de la instrucción 29 (`CBZ X0, loop1`). Luego, en t = 0.315 ns continúa con el Decode de la instrucción 29 mientras se realiza el Fetch de la instrucción 30 (`STUR X21, [X0, #128]`). En t = 0.325 ns, la instrucción 29 pasa de Decode a Execute. Mientras tanto, se realiza el Decode de la instrucción 30 y comienza el Fetch de la 31 (`STUR X21, [X0, #136]`). En t = 0.335 ns, el `CBZ` llega a Memory, seteando la señal `PCSrc` en 1 porque debe realizar el salto. Las instrucciones 30 y 31 avanzan una etapa en el pipeline, mientras se hace el Fetch de la instrucción 32 (`ADD X2, XZR, X1`). Cuando el `CBZ` llega a Writeback, en t = 0.345 ns, se ejecuta el salto hacia la instrucción 31, a la cual se le hace Fetch. Sin embargo, las instrucciones 30, 31 y 32 que ya están en el pipeline siguen avanzando, produciendo un **hazard de control**. De lo contrario, las señales `EX_MEM_regWrite`, `EX_MEM_memWrite`, y `ID_EX_regWrite`, `ID_EX_memWrite` (correspondientes a las instrucciones 31 y 30 previamente cargadas, respectivamente) deberían pasar a 0. #### Programa modificado con agregado de instrucciones `NOP` Se realizaron modificaciones al programa agregando instrucciones `NOP` para evitar los hazards y obtener el resultado deseado del mismo, a continuación se muestra el programa modificado ```s STUR X1, [X0, #0] STUR X2, [X0, #8] STUR X3, [X16, #0] ADD X3, X4, X5 STUR X3, [X0, #24] SUB X3, X4, X5 STUR X3, [X0, #32] SUB X4, XZR, X10 STUR X4, [X0, #40] ADD X4, X3, X4 STUR X4, [X0, #48] SUB X5, X1, X3 STUR X5, [X0, #56] AND X5, X10, XZR STUR X5, [X0, #64] AND X5, X10, X3 STUR X5, [X0, #72] AND X20, X20, X20 STUR X20, [X0, #80] ORR X6, X11, XZR STUR X6, [X0, #88] ORR X6, X11, X3 STUR X6, [X0, #96] LDUR X12, [X0, #0] ADD X7, X12, XZR STUR X7, [X0, #104] STUR X12, [X0, #112] ADD XZR, X13, X14 STUR XZR, [X0, #120] CBZ X0, loop1 STUR X21, [X0, #128] loop1: STUR X21, [X0, #136] ADD X2, XZR, X1 loop2: SUB X2, X2, X1 ADD X24, XZR, X1 STUR X24, [X0, #144] ADD X0, X0, X8 CBZ X2, loop2 STUR X30, [X0, #144] ADD X30, X30, X30 SUB X21, XZR, X21 ADD X30, X30, X20 LDUR X25, [X30, #-8] ADD X30, X30, X30 ADD X30, X30, X16 STUR X25, [X30, #-8] finloop: CBZ XZR, finloop ``` #### Contenido de la memoria al finalizar la ejecución del programa modificado ``` Memoria RAM de Arm: Address Data 0 0000000000000001 1 0000000000000002 2 0000000000000003 3 0000000000000009 4 FFFFFFFFFFFFFFFF 5 FFFFFFFFFFFFFFF6 6 FFFFFFFFFFFFFFF5 7 0000000000000002 8 0000000000000000 9 000000000000000A 10 0000000000000014 11 000000000000000B 12 FFFFFFFFFFFFFFFF 13 0000000000000001 14 0000000000000001 15 0000000000000000 16 0000000000000000 17 0000000000000015 18 0000000000000001 19 0000000000000001 20 000000000000001E 21 000000000000000A 22 0000000000000000 23 0000000000000000 24 0000000000000000 ... 61 0000000000000000 62 0000000000000000 63 0000000000000000 ``` --- ### Ejercicio 2 En este ejercicio se propone la implementación de un bloque de detección de hazards (Hazard Detection Unit) a fin de insertar stalls en forma automática en caso de la ocurrencia de un data hazard, hasta que el mismo desaparezca. #### Modificaciones implementadas Resaltados en rojo se encuentran los cambios realizados al microprocesador original. **Cambios en el modulo `ProcessorARM`** Se agregó un Mux `NOP` (podría llamarse `flush`) que en caso de la ocurrencia de un hazard de control se encarga de realizar el flush de la etapa IF/ID poniendo las señales de control en 0 y enviándolas hacia el modulo datapath, realizando asi el flush de la etapa IF/ID. ![](https://i.imgur.com/s4hOkjC.png) **Cambios en el módulo `Datapath`** Se agregó una señal de stall que se usa para forzar que todas las señales de control a partir del ciclo EX en adelante tomen el valor 0 en caso de una ocurrencia de hazard de datos. Para esto se agregó un Mux `ID_EX_Control`. Esta nueva señal de stall tambien se utiliza para evitar que el registro de pipeline IF/ID cambie de valor en el siguiente clock (congelando su valor). Tambien se está utilizando la señal de `PCSrc_M` para identificar la ocurrencia de un hazard de control, en caso de un hazard de este tipo se genera el flush de las instrucciones cargadas erróneamente en el microprocesador limpiando las señales de control de los registros IF/ID, ID/EX y EX/MEM. Para esto se usa el Mux previamente mencionado `ID_EX_Control`, se agrega un nuevo Mux `EX_MEM_Control` y se utiliza la señal de PCSrc en el modulo processor_arm. ![](https://i.imgur.com/pHTcx4j.png) **Cambios en el módulo `Decode`** En este módulo se agregó la Hazard Detection Unit que al encontrar una condición de hazard de datos verdadera genera la condición de stall en el procesador. ![](https://i.imgur.com/RKMABlJ.png) **Cambios en el módulo `Fetch`** En este módulo se agregó una señal de enable que está en 0 cuando hay una condición de stall, esto evita que el PC avance a la siguiente instrucción en el siguiente clock cuando hay una dependencia de datos, produciendo así un stall. ![](https://i.imgur.com/5xJNBpq.png) #### Ejecución con presencia de un hazard de datos Volvamos a analizar el siguiente segmento de código, que presenta hazard de datos, para verificar si en verdad se realiza el stall. ```s 3> ADD X3, X4, X5 4> STUR X3, [X0, #24] 5> ... ``` ![](https://i.imgur.com/ExmHtB5.png) En t = 0.065 ns, cuando se realiza el Execute de la instrucción 3 (`ADD X3, X4, X5`) y el Decode de la 2 (`STUR X3, [X0, #24]`), el procesador entra en stall hasta t = 0.085 ns. Mientras está en stall, las instrucción 3 y anteriores siguen avanzando en el pipeline, mientras que la instrucción 2 y las siguientes se detienen y el PC deja de avanzar. En t = 0.085 ns, la instrucción 3 llega a Writeback y se escribe el registro `X3` con el valor *9*. El procesador sale del stall y se realiza el Decode, leyendo correctamente el nuevo valor del registro. #### Ejecución con presencia de un hazard de control También veamos nuevamente la siguiente sección de código con un hazard de control ```s 29> CBZ X0, loop1 30> STUR X21, [X0, #128] loop1: 31> STUR X21, [X0, #136] 32> ADD X2, XZR, X1 ``` ![](https://i.imgur.com/21MG9jg.png) En t = 0.545 ns comienza el Fetch de la instrucción 29 (`CBZ X0, loop1`). Durante los próximos ciclos de reloj, la instrucción avanza en el pipeline mientras entran la instrucción 30, 31 y 32 sucesivamente. Al llegar a t = 0.575 ns, el `CBZ` llega a Memory, donde el procesador calcula que debe tomarse el salto. `PCSrc` pasa a 1 y todas las señales de control de ID/EX y EX/MEM pasan a 0, evitando que las instrucciones ya cargadas sigan avanzando en el pipeline. A continuación, se realiza el salto a la instrucción 31, que entra en Fetch. --- ### Ejercicio 3 Este ejercicio se trata de implementar una ISR (Interruption Service Routine) en un microprocesador ARMv8 de un ciclo con excepciones. Ante la ocurrencia de una excepción por OpCode invalido, en primer lugar determin qué tarea de las que actualmente gestiona el OS generó la excepción, la elimina del planificador (Scheduler) y continúa con la ejecución de la próxima tarea disponible de prioridad más alta. #### Modificaciones introducidas Se realizaron las siguientes modificaciones: - **Agrandar los módulos de memoria**: Se modificaron los modulos `processor_arm`, `imem` y `dmem` para que la memoria de instrucciones acepte hasta 128 instrucciones de 32 bits y para que la memoria de datos acepte 256 palabras de 64 bits. - **Implementacion de la instruccion BR**: Se modificaron los modulos `maindec` y `controller` para tener una nueva instruccion BR con Opcode: `11010110000`, para esto fue necesario agregar una nueva señal de control `BranchtoReg` que se settea a 1 en presencia de esta instruccion. Ademas se modificaron los modulos datapath y execute agregando un Mux que dada la señal `BranchtoReg` hace un salto hacia el contenido del registro `Rn`. Resaltados en rojo se encuentran los cambios realizados al microprocesador original. **Cambios en el modulo `ProcessorARM`** ![](https://i.imgur.com/ghB3e1C.png) **Cambios en el modulo `Datapath`** ![](https://i.imgur.com/oQvO8tK.png) **Cambios en el modulo `Execute`** ![](https://i.imgur.com/CgMnhIY.png) #### Código assembler con implementación de la ISR ```s .text .org 0x00 ADD X9, XZR, X30 ADD X10, XZR, XZR STUR X10, [X10, #0] ADD X10, X10, X8 SUB X9, X9, X1 CBZ X9, break BR X8 finloop: CBZ XZR, finloop ADD X9, XZR, X16 ADD X11, XZR, XZR loop: STUR X11, [X10, #0] ADD X10, X10, X8 ADD X11, X11, X1 SUB X9, X9, X1 CBZ X9, finloop CBZ XZR, loop break: MUL XZR, XZR, XZR // Vector de excepciones con ISR .org 0xD8 MRS X13, S2_0_C2_C0_0 SUB X13, X13, X2 CBZ X13, init1024Register ERET init1024Register: ADD X28, X8, X1 ADD X30, XZR, X2 loop: ADD X30, X30, X30 SUB X28, X28, X1 CBZ X28, handleInvalidOpCode CBZ XZR, loop handleInvalidOpCode: ADD X29, X30, XZR ADD X29, X29, X16 findOffenderInstr: LDUR X15, [X29, #0] SUB X15, X15, X4 CBZ X15, findOffenderInstrEnd ADD X29, X29, X16 ADD X29, X29, X16 ADD X29, X29, X16 CBZ XZR, findOffenderInstr findOffenderInstrEnd: STUR XZR, [X29, #0] findReadyInstr: ADD X29, X30, XZR ADD X29, X29, X16 findReadyInstrStart: LDUR X15, [X29, #0] SUB X15, X15, X5 CBZ X15, findReadyInstrEnd ADD X29, X29, X16 ADD X29, X29, X16 ADD X29, X29, X16 CBZ XZR, findReadyInstrStart findReadyInstrEnd: STUR X4, [X29, #0] LDUR X15, [X29, #24] BR X15 ``` #### Contenido de memoria al finalizar la ejecución del código anterior ``` Memoria RAM de Arm: Address Data 0 0000000000000000 1 0000000000000008 2 0000000000000010 3 0000000000000018 4 0000000000000020 5 0000000000000028 6 0000000000000030 7 0000000000000038 8 0000000000000040 9 0000000000000048 10 0000000000000050 11 0000000000000058 12 0000000000000060 13 0000000000000068 14 0000000000000070 15 0000000000000078 16 0000000000000080 17 0000000000000088 18 0000000000000090 19 0000000000000098 20 00000000000000A0 21 00000000000000A8 22 00000000000000B0 23 00000000000000B8 24 00000000000000C0 25 00000000000000C8 26 00000000000000D0 27 00000000000000D8 28 00000000000000E0 29 00000000000000E8 30 0000000000000000 31 0000000000000001 32 0000000000000002 33 0000000000000003 34 0000000000000004 35 0000000000000005 36 0000000000000006 37 0000000000000007 38 0000000000000008 39 0000000000000009 40 000000000000000A 41 000000000000000B 42 000000000000000C 43 000000000000000D 44 000000000000000E 45 000000000000000F 46 0000000000000000 47 0000000000000000 48 0000000000000000 ... 126 0000000000000000 127 0000000000000000 128 0000000000FFD000 129 0000000000000002 130 0000000000000002 131 0000000000000098 132 00000000000000B8 133 00000000000000A0 134 0000000000C0CA00 135 0000000000000005 136 0000000000000000 137 0000000000000060 138 0000000000000088 139 0000000000000070 140 0000000000CAFE00 141 0000000000000006 142 0000000000000004 143 0000000000000010 144 0000000000000058 145 0000000000000020 146 0000000000000000 147 0000000000000000 148 0000000000000000 149 0000000000000000 150 0000000000000000 151 0000000000000000 ... 253 0000000000000000 254 0000000000000000 255 0000000000000000 ```

Syntax	Example	Reference
# Header	Header	基本排版
- Unordered List	Unordered List
1. Ordered List	Ordered List
- [ ] Todo List	Todo List
> Blockquote	Blockquote
Bold font	Bold font
Italics font	Italics font
~~Strikethrough~~	~~Strikethrough~~
19^th^	19^th
H~2~O	H₂O
++Inserted text++	Inserted text
==Marked text==	Marked text
[link text](https:// "title")	Link
![image alt](https:// "title")	Image
`Code`	`Code`	在筆記中貼入程式碼
```javascript var i = 0; ```	`var i = 0;`
:smile:		Emoji list
{%youtube youtube_id %}	Externals
$L^aT_eX$	L^aT_eX
:::info This is a alert area. :::	This is a alert area.