---
# System prepended metadata

title: 'Ćwiczenia 5, grupa śr. 17-19, 6. kwietnia 2022'
tags: [SYK21, pwit, ćwiczenia]

---

# Ćwiczenia 5, grupa śr. 17-19, 6. kwietnia 2022

###### tags: `SYK21` `ćwiczenia` `pwit`

## Deklaracje

Gotowość rozwiązania zadania należy wyrazić poprzez postawienie X w odpowiedniej kolumnie! Jeśli pożądasz zreferować dane zadanie (co najwyżej jedno!) w trakcie dyskusji oznacz je znakiem ==X== na żółtym tle.

**UWAGA: Tabelkę wolno edytować tylko wtedy, gdy jest na zielonym tle!**


:::danger
|                        | 1     | 2   | 3   | 4   | 5   | 6   | 7   | 8   | 9  | 10 | 11 |
| ----------------------:| ----- | --- | --- | --- | --- | --- | --- | --- |--- |--- |--- |
Grzegorz Bielecki        |       |     |     |     |     |     |     |     |    |    |    |
Kamila Brzozowska        |   X   | ==X==|  X   |  X   |  X   |  X   |  X   |  X  | X  |    |    |
Adam Ciężkowski          |   X    |  X   |  X   |  X   |  X   |  X   |  X   |  X   |    |  X  |    |
Natalia Czerep           |   X    |  X   |   x  |  X   |  X   |  X   |  X   |     |    |    |    |
Jan Dalecki              |   X    |  X   |   X  |  X   |   X  |  X   |   X  |  X   |  X  | ==X==   |  X  |
Marko Golovko            |   X   |   X |  X  |  X  |  X  |  X  |  X  |  X  |    |    |    |
Adam Górkiewicz          |   X   |  X  |  X  |  X  |  X  |  X  |  X  |  X  |  X |  X |  X |
Piotr Gunia              |    X   | X    | X    |  X   |  X   |  X   |   X  | X    |    | X   |    |
Krzysztof Jadłowski      |     X  | X    |  X   |  X   |     |     |     |     |    |    |    |
Magdalena Jarecka        |   X    |   X  |  X   |  X   |  X   |   X  |     |     |  X  |  X  |    |
Mikołaj Jaszcza          |   X   |  X  |  X  |  X  |  X  |  X  |  X  |  X  |    |    |    |
Monika Jędrzejkowska     |       |     |     |     |     |     |     |     |    |    |    |
Michał Kierul            |   X    |  X   |   X  |   X  |   X  |     |     |     |    |    |    |
Damian Lukas             |       |     |     |     |     |     |     |     |    |    |    |
Karol Ochman-Milarski    |       |     |     |     |     |     |     |     |    |    |    |
Piotr Piesiak            |       |     |     |     |     |     |     |     |    |    |    |
Damian Ratajski          |       |     |     |     |     |     |     |     |    |    |    |
Aleksandra Rozkrut       |   X   |  X  |  X  |  X  |==X==|  X  |     |  X   |    |    |    |
Marcin Sarnecki          |   X   |  X  |  X  |==X==|  X  |  X  | X   |  X  |    |    |    |
Maria Szlasa             |   X   |  X  |  X  |  X  |  X  |  X  |     |     |    |    |    |
Mateusz Burdyna          | ==X== |  X  |  X  |  X  |  X  |  X  |     |  X  |    | X  |    |
Nikola Wrona             |   X   |  X  |  X  |  X  |  X  |  X  |     |     |    |    |    |
Marcin Wróbel            |   X   |  X  |==X==|  X  |  X  |  X  |  X  |  X  |  X  |  X  |    |
:::






:::info
**Uwaga:** Po rozwiązaniu zadania należy zmienić kolor nagłówka na zielony.
:::

## Zadanie 1
:::success
Autor: Mateusz Burdyna
:::
![](https://i.imgur.com/E6KBdMO.png)
![](https://i.imgur.com/iH2iROR.png)

## Zadanie 2
:::success
Autor: Kamila Brzozowska
:::
*(x +imm) = y
![](https://i.imgur.com/vTEJ79p.png)

## Zadanie 3
:::success
Autor: Marcin Wróbel
:::
$x = y\ binop\ z$
![](https://i.imgur.com/DaiUmsB.png)

- Adres instrukcji `PC` jest przekazywany do Instruction Memory
- Następnie w sumatorze zostaje dodane 4 do PC, wynika to z tego, że instrukcje w pamięci są przechowywane na 4 bajtach.
- Adres zwiększony o `4` zostaje przekazany dalej do multipleksera, który przekaże tą wartość jako adres kolejnej instrukcji
- Obok następuje odczyt instrukcji z Instruction Memory
- Przekazane z Instruction Memory ``"y"`` i ``"z"`` są odczytywane z rejestru procesora w register file i dostajemy na wyjściu `y`, `z`
- Następnie `y`, `z` jest przekazane do ALU
- Za pomocą odczytanego przez control unit binopa
W ALU wykonane zostaje `y binop z`
- Wynik powyższego działania przechodząc przez multiplekser jest przekazywany do WD3 w Register file
- W Register file dostało na WE3 1, więc 
na adresie `"x"` rejestru procesora zostanie zapisane `y binop z`

## Zadanie 4
:::success
Autor: Marcin Sarnecki
:::
if x relop y goto L

![](https://i.imgur.com/tSOFUxN.png)

Adres PC przekazujemy do Instruction memory
Odczytujemy instrukcje o adresie PC z pamięci
Poniżej dodajemy 4 do PC (instrukcje są zapisywane na 4 bajtach)
Control unit dostanie relop'a, register file dostanie adresy "x" oraz "y"
L zostanie przekazany do sign extend
Instrukcje są zapisane na 4 bajtach, więc L jest mnożone razy 4 (przesuwane o 2 bity w lewo)
L jest sumowane z PC, wynik przekazujemy do multipleksera, który decyduje, czy wykonujemy skok
Przekazane "x" i "y" są odczytywane z rejestru procesora w register file i dostajemy na wyjściu x, y
Za pomocą odczytanego przez control unit relop'a w ALU wykonane zostaje x relop y
Wynik tego porównania jest łączony w bramce AND z informacją o tym, że jest to instrukcja skoku warunkowego i przekazywany do multipleksera, który decyduje o nowej wartości licznika rozkazów

## Zadanie 5
:::success
Autor: Aleksandra Rozkrut
:::
![](https://i.imgur.com/hFOrlKc.png)

![](https://i.imgur.com/FEE5aMp.png)

`x = y binop imm`

![](https://i.imgur.com/tjT9nZc.png)
![](https://i.imgur.com/tVlqdA2.png)

`goto L`

![](https://i.imgur.com/72eeHpi.png)
Dwa najmłodsze bity PC to zawsze 0 (wielokrotność 4). Następne 26 bitów zawsze bierzemy z `L` w instrukcji. Cztery pozostałe bity są brane ze starej wartości PC.

## Zadanie 6
:::success
Autor: Piotr Gunia
:::

![](https://i.imgur.com/Ipm1K8m.png)

![](https://i.imgur.com/o3l6SPY.png)

---

![](https://i.imgur.com/PsqztKa.png)

:::spoiler rozwiązanie z ćwiczeń
a) x = *(y+imm)
50 + 250 + max(**150**, 50 + 25) + 200 + 250 + 25 + 150 = 1075ps

b) *(x+imm) = y
50 + 250 + 150 + 200 + 250 = 900ps

c) x = y binop z
50 + 250 + 150 + 25 + 200 + 25 + 150 = 850

d) if x relop y goto z
50 + 250 + max(**150 + 25 + 200**, 50 + 150) + 25 = 700

e) x = y binop imm
50 + 250 + 150  + 200 + 25 + 150 = 825

f) goto L
50 + 250 + 50 + 25 = 375

Cykl procesora musi trwać co najmniej 1075ps
:::

a) x = *(y+imm)
![](https://i.imgur.com/mgjzFgF.png)
50 + 250 + max(**150**, 50 + 25) + 200 + 250 + 25 + 150 = 1075ps

b) *(x+imm) = y
![](https://i.imgur.com/2BB1mId.png)
50 + 250 + 150 + 200 + 250 = 900ps

c) x = y binop z
![](https://i.imgur.com/X1giPj4.png)
50 + 250 + 150 + 25 + 200 + 25 + 150 = 850

d) if x relop y goto z
![](https://i.imgur.com/HhROA7L.png)

50 + 250 + max(**150 + 25 + 200**, 50 + 150 + 25 + 25) + 25 + 25 = 

e) x = y binop imm
![](https://i.imgur.com/dzxRfXr.png)

50 + 250 + 150 + 200 + 25 + 150 = 825

f) goto L
![](https://i.imgur.com/sdFanIB.png)

50 + 250 + 50 + 25 = 525

Cykl procesora musi trwać co najmniej 1075ps

## Zadanie 7
:::success
Autor: Mikołaj Jaszcza
:::

![](https://i.imgur.com/0ZQIsrt.png)

Czas dla $[ x = *(y+ imm) ]  = 1075ps$
Czas dla $[ *(x +imm) = y ] = 900ps$
Czas dla $[ if\ x\ relop\ y\ goto\ L ] = 700ps$
Czas dla $[ x = y\ binop\ z ] = 850ps$

Maksymalny czas -> 1075ps (taki musiałby być dla każdej operacji jeżeli musiałby być stały).

Jeśli jednak czas mógłby być zmienny - wystarczy obliczyć średnią ważoną (w zależności od użycia) aby poznać średni czas wykonania pojedynczej operacji.

25% * 1075 + 11% * 900 + 12% * 700 + 52% * 850 = 893.75ps = 83.13% * 1075ps

Osiągnęlibyśmy więc około 17% przyspieszenia.



## Zadanie 8
:::success
Autor: Adam Ciężkowski
:::

![](https://i.imgur.com/ofWG2OI.png)

![](https://i.imgur.com/lnhA71r.png)



## Zadanie 9
:::success
Autor: Magdalena Jarecka
:::

Niestety nie możemy konwencjonalnie wykonać operacji swap. Register File pozwala nam tylko na jedno Write Register więc nasz "zmyślony" układ obsługujący operację swap wyglądał by tak:![](https://i.imgur.com/aQm9iBs.jpg)

![](https://i.imgur.com/f7iOV2M.png)



## Zadanie 10
:::success
Autor: Jan Dalecki
:::

$*x = y+imm$
Pod adres zapisany w rejestrze $x$ zapisujemy sumę $y+imm$, gdzie $y$ to wartość w rejestrze, a $imm$ to stała zapisana w kodzie instrukcji.

#### Zmodyfikowany układ
Dodaliśmy moduł swap IO który na podstawie sygnału z control unit zamienia wyjścia obydwu wejść. Umieszczamy go przed pamięcią, aby móc ustalić czy adres będzie przychodził z RD1 czy z RD2.
![](https://i.imgur.com/SU6gPMN.png)

Przepływ dla nowej instrukcji:
![](https://i.imgur.com/sZ4YEPP.png)

Implementacja modułu swap IO:

![](https://i.imgur.com/FfdBmXP.png)



## Zadanie 11
:::success
Autor: Adam Górkiewicz
:::

Każdą operację (a) oraz (b) zamieniamy na dwie inne.
Długość cyklu starego procesora: $C_{prev} = 1075$ (dla operacji $\texttt{x = *(y + imm)}$)
Długość cyklu nowego procesora: $C_{new} = 850$ (dla operacji $\texttt{x = y binop z}$)
Oznaczmy przez $p$, jaką część operacji obejmują operacje (a) i (b). Wówczas
Średni czas wykonania operacji starego procesora: $C_{prev}$
Średni czas wykonania operacji nowego procesora: $(1 - p) \cdot C_{new} + p \cdot C_{new} \cdot 2 = C_{new}(1 + p)$
Modyfikacja jest więc opłacalna wtedy i tylko wtedy gdy $\frac{C_{new}}{C_{prev}} < \frac{1}{1 + p}$






