# Ćwiczenia 6, grupa cz. 10-12, 4 kwietnia 2024

###### tags: `SYK24` `ć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 |
| ----------------------:| -----| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
Borys Adamiak | X | X | X | X | | | X | | | | |
Michał Chawar | X | X | X | X | X | X | X | X | | X | |
Julia Cygan | X | X | X | X | X | X | ==X== | X | X | X | |
Maciej Dengusiak | ==X== | X | X | X | X | X | X | X | X | X | |
Patryk Flama | X | X | X | ==X== | X | X | X | X | X | X | |
Szymon Fluder | X | X | X | X | X | X | X | X | | X | X |
Aleksandra Jędrzejak | X | X | X | X | | | | | | | |
Mikołaj Karapka | X | X | ==X== | X | X | X | X | X | | | |
Viktoriia Kashpruk | X | X | X | X | X | X | X | X | | X | |
Wiktor Małek | | | | | | | | | | | |
Błażej Molik | X | ==X== | X | X | X | X | X | X | X | X | |
Andrzej Morawski | | | | | | | | | | | |
Konrad Oleksy | | | | | | | | | | | |
Lucjan Pucelak | X | X | X | X | | | | | | | |
Aleksandra Sęk | X | X | X | X | X | X | X | X | | | |
Radosław Śliwiński | | | | | | | | | | | |
Piotr Traczyński | | | | | | | | | | | |
~~Katarzyna Trzos (deklaracja wykreślona) | X | X | X | X | | | | | | | |~~
Piotr Warząchowski | X | X | X | X | | X | X | | | | |
Olga Zaborska | X | X | X | X | | X | X | X | | | |
:::

Poniżej można zadeklarować zadania **3** i **4** z **listy 5**.

:::danger
| | 5.3 | 5.4 |
| ----------------------:| -----| --- |
Borys Adamiak | | |
Michał Chawar | | |
Julia Cygan | | |
Maciej Dengusiak | | |
Patryk Flama | | |
Szymon Fluder | | |
Aleksandra Jędrzejak | | |
Mikołaj Karapka | | |
Viktoriia Kashpruk | X | |
Wiktor Małek | | |
Błażej Molik | | |
Andrzej Morawski | | |
Konrad Oleksy | | |
Lucjan Pucelak | | |
Aleksandra Sęk | | |
Radosław Śliwiński | | |
Piotr Traczyński | | |
Katarzyna Trzos | | |
Piotr Warząchowski | | |
Olga Zaborska | | |
:::

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

## Zadanie 1
:::success
Autor: Maciej Dengusiak


INSTRUKCJA: **LW x =*(y+imm)**
1. Pobranie instrukcji z licznika rozkazów (Faza fetch)
2. Pobieramy wartości zmiennej y w A1 (Ustalamy wartości zmiennych w register file)
3. Wartość **imm** jest zapisana na bitach 0-15 i rozszerzamy ją do 32 bitów w **Sign Extend**
4. Dodajemy w **ALU** (jednostka arytmetyczno-logiczna) wartość **y** oraz **imm**
5. Z ALUResult Przekazujemy do DataMemory
6. Stamtąd do RegisterFile spowrotem dajemy wartość **y + imm** i referencje do **x** oraz ustawiamy **RegWrite** na 1 (bo zapisujemy wartość)
7. Dodaj do licznika rozkazów + 4bajty (każda instrukcja ma 32 bity) - przejdz do kolejnej instrukcji
:::

## Zadanie 2
:::danger
Autor: Katarzyna Trzos
:::

## Zadanie 3
:::success
Autor: Mikołaj Karapka

Tak jak w poprzednich zadaniach musimy pokazać ścieżke przepływu danych, ale tym razem dla $x = y \ binop \ z$

**Lista kroków:**
1. Pobranie instrukcji. Przekazanie $y$ i $z$ do **RegisterFile** w celu odczytania ich wartości.
2. Przejście do **Control Unit** i ustawienie następujących wartości:
- **MemtoReg** na 0
- **ALUControl** na daną kombinację $\{{a,b,c \ | \ a,b,c \in { \{ 0,1} \} \} }$
- **ALUSrc** na 0
- **RegDst** na 1
- **RegWrite** na 1
3. Przekazanie $x$ do multiplexera i zajęcie przez niego **A3**
4. Operacja binarna (binop) na $y$ (SrcA) i $z$ (ScrB) w **ALU**
5. Przejście wyniku operacji przez multiplexer
6. Przypisanie wyniku operacji do **WD3**
7. Przypisanie **WD3** do **A3** i zapisanie wartości $x$ do **RegisterFile**
:::

## Zadanie 4
:::success
Autor: Borys Adamiak
:::

INSTRUKCJA: **if x relop y goto L, dla instrukcji ==**

Możemy jednocześnie tylko odczytanie 2 wartości, dlatego fragment adresu skoku zapiszemy w instrukcji.

Przechowamy **stałą ze znakiem** i następnie z niej obliczymy kolejną instrukcję.
**BTA = (sign-extended immediate << 2) + (PC+4)**

1. Bierzemy 16 bitów, gdzie zakodowana nasza stała (sign-extended immediate) oraz aktualne PC - nr instrukcji
2. Rozszerzamy stałą do 32 bitów i **obliczamy wartość BTA** (skoku) w PCBranch
3. Sprawdzamy czy wyjście **zero w ALU jest true**, jeśli tak to **x == y** zachodzi
4. Jeśli w
- **Zero jest true** (warunek zachodzi)
- **Branch jest true** (mamy operację beq)
To przekazujemy, że należy wykonać skok, a doką liczymy **BTA**

ReqWrite oraz MemWrite będą zerami stąd nie będziemy niepotrzebnie zapisywali danych w DataMemory lub RegisterFile

## Zadanie 5
:::success
Autor: Aleksandra Sęk
:::

## Zadanie 6
:::success
Autor: Olga Zaborska
:::


#### a)
$T_{pcq\_PC} + T_{mem} + max(T_{RFread}, T_{sext} + T_{mux}) + T_{ALU} + T_{mem} + T_{mux} + T_{RFsetup} =
[50 + 250 + 150 + 200 + 250 + 25 + 150]ps = 1075ps$

#### b)
$T_{pcq\_PC} + T_{mem} + max(T_{RFread}, T_{sext} + T_{mux}) + T_{ALU} + T_{mem} =
[50 + 250 + 150 + 200 + 250]ps = 900ps$

#### c)
$T_{pcq\_PC} + T_{mem} + T_{RFread} + T_{mux} + T_{ALU} + T_{mux} + T_{RFsetup}=
[50 + 250 + 150 + 25 + 200 + 25 + 150]ps = 850ps$

#### d)
$T_{pcq\_PC} + T_{mem} + max(T_{RFread} + T_{mux} + T_{ALU}, T_{sext} + T_{add}) + T_{mux}=
[50 + 250 + (150 + 25 + 200) + 25]ps = 700ps$

#### e)
$T_{pcq\_PC} + T_{mem} + T_{RFread} + T_{ALU} + T_{mux} + T_{RFsetup} =
[50 + 250 + 150 + 200 + 25 + 150]ps = 825ps$

#### f)
$T_{pcq\_PC} + T_{mem} + T_{ctrl} + T_{mux}=
[50 + 250 + 50 + 25]ps = 375ps$

## Zadanie 7
:::success
Autor: Piotr Warząchowski
Czas dzialania poszczegolnych operacji:

Czas dzialania procesora z zad 6 : 1075ps,
Czasy poszczeolnych operacji mozna znalezc w zad 6.

Podsumowywujac:

0.25 * 1075 + 0.11 * 900 + 0.12 * 675 + 0.52 *825 ps = 878 ps

(1075 - 878) / 1075 = 0.18. Czyli nasze przyspiszenie jest rzedu 18%
:::

## Zadanie 8
:::success
Autor: Szymon Fluder


Nie trzeba dodawać nowych komponentów ani modyfikować istniejących. Musimy wprowadzić nową instrukcję - to samo, co w zadaniu nr.3, tylko ustawiamy MemToReg na 1.
:::

## Zadanie 9
:::success
Autor: Błażej Molik
:::
Rozszerzamy układ o wejścia A4, WD4, WE4, ponieważ chcemy móc zapisywać wartości do dwóch zmiennych w jednym cyklu.
Potem łączymy RD1 z nowym multiplekserem, który dostaje wartość 0 i przepinamy do WD3. Dodatkowo łączymy RD2 bezpośrednio z WD4.
Teraz "x" pójdzie do A1 i A4, a "y" do A2 i A3, a wartości x i y odpowiednio do WD3, WD4

## Zadanie 10
:::success
Autor: Viktoriia Kashpruk

:::

## Zadanie 11
:::success
Autor: Szymon Fluder


a) `t = y + imm`: PC + MEM + REG + ALU + REG = 50 + 250 + 150 + 200 + 150 = 800ps

b) `x = *t`: PC + MEM + REG + MEM + REG = 50 + 250 + 150 + 250 + 150 = 850ps
*poprawka:*
IM + RF + MUX + DM + MUX + RF = 850ps

c) `*t = x`: to samo co powyżej, czyli 850ps
*poprawka:*
IM + RF + MUX + DM = 675ps

> [name=Piotr Witkowski] Najcięższa ścieżka dla instrukcji ``x=*y``: IM + RF + MUX + DM + MUX + RF. Uwaga: implementacja tej funkcji wymaga dodania mulitpleksera pomijającego ALU! (800ps). Czas ``*t = x`` wynosi 625ps.

**Poprzednie czasy instrukcji**:
A)
`x = *(y + imm)`
PC + MEM + REG + ALU + MEM + REG = 50 + 250 + 150 + 200 + 250 + 150 = 1050ps

B)
`*(x + imm) = y`
PC + MEM + REG + ALU + MEM = 50 + 250 + 150 + 200 + 250 = 900ps

**Zmienione czasy instrukcji**:
A)
zmieniamy na instrukcje a oraz b = 800ps + 850ps = 1650ps

B)
zmieniamy na instrukcje a oraz c = 800ps + 675ps = 1475ps

**Konkluzja**:
Zmniejszyliśmy czas cyklu procesora, lecz zwiększyliśmy jednocześnie czas wykonywania się bardzo popularnych instrukcji. W konsekwencji program będzie się wykonywał dłużej na zmodyfikowanym procesorze.

*poprawka*
Zmodyfikowany procesor nie zawsze będzie działał wolniej od poprzedniego (n.p. gdy wykonuje on programy, gdzie jest dużo obliczeń, a mało dostępów do pamięci). Są jednak programy (takie, gdzie dostępów do pamięci jest dużo), które będą działać wolniej.

:::