---
# System prepended metadata

title: 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

```