# Ćwiczenia 5, grupa cz. 12-14, 7. 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 |
| ----------------------:| ----- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
Daniel Boguszewski | X | X | X | X | X | X | | X | X | | |
Adam Ciężkowski | | | | | | | | | | | |
Jacek Długopolski | x | x | x | x | x | x | x | x | x | x | |
Jakub Fila | X | X | X | X | X | X | X | X | | | |
Krzysztof Grynkiewicz | | | | | | | | | | | |
Michał Hetnar | x | x | x | x | x | x | x | x | | x | |
Hubert Jabłoński | x | x | x | x | x | x | x | x | x | x | |
Antoni Kamiński | X | X | X | | | | X | | | | |
Paweł Karaś|X|X|X|X|X|X|X|X|X|X| |
Emil Kisielewicz | X | X | X | X | X | X | X | X | ==X== | X | |
Kacper Komenda | X | X | X | X | ==X== | X | X | | | | |
Filip Komorowski | x | x | x | x | x | x | x | ==x== | | x | x |
Piotr Piesiak | x | ==x== | x | x | x | x | x | x | | x | x |
Artur Krzyżyński | ==x== | x | x | x | x | x | x | x | x | x | x |
Patryk Mazur | X | X | X | X | X | X |==X==| X | | | |
Szymon Mleczko | X | X | X | X | X | X | X | X | X | X | |
Michał Mróz | | | | | | | | | | | |
Dominik Olejarz | x | x | x | x | x | x | | | | | |
Magdalena Słonińska | | | | | | | | | | | |
Oleś Kulczewicz | X | X | X | X | X | X | X | X | X | | |
Adam Szeruda | x | x |==x==| x | x | x | x | x | x | x | x |
Kamil Tasarz | X | X | X | X | X | X | X | X | | X | |
Michał Zieliński |==X== | X | X | X | X | X | X | X | X | X | |
:::

**Tutaj można do-deklarować zad. 8. z listy 4:**

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

## Zadanie 1
:::success
Autor: Michał Zieliński
:::

### Treść
Pokaż ścieżkę przepływu danych w prostym
jednocyklowym procesorze$^{1}$ wykonującym instrukcję x = *(y+ imm),
gdzie x i y są rejestrami, a imm stałą.

$^{1}$ w wariancie widocznym na slajdzie 17

### Rozwiązanie


## Zadanie 2
:::success
Autor: Piotr Piesiak
:::
*(x +imm) = y

1. W PC przetwarzamy instrukcję
2. Zwiększamy adres instrukcji, która następnie czeka w początkowym MUX na kolejny cykl (nie ma sygnału JUMP z Control Unit)
3. Rozbijamy instrukcję x,y i imm
4. Imm przechodzi przez Sign Extend (stała ma 16 bitów - zwiększamy do 32), a następnie przez MUX z sygnałem 1 wchodzi do ALU
5. x po odczytaniu rejestru, przechodzi do ALU
6. w ALU sumujemy x,imm (poprzez odpowiedni sygnał z Control Unit)
7. W Data Memory otrzymujemy zsumowane x,imm odpowiadające za adres do zapisu oraz y oznaczający wartość, którą zapiszemy.
8. Data Memory zapisuje do adresu (x + imm) wartość y, ponieważ otrzymuje odpowiedni sygnał z Control Unit.

## Zadanie 3
:::success
Autor: Adam Szeruda
:::

Powtórz powyższe zadanie dla instrukcji `x = y binop z`,
gdzie `binop` jest binarnym operatorem arytmetycznym.


## Zadanie 4
:::success
Autor: Daniel Boguszewski
:::
Wartość L, po jej odpowiednim przetworzeniu, dodajemy do bieżącej wartości licznika rozkazu PC, podczas gdy wartości x, y przekazujemy do przetworzenia przez ALU. Jeżeli relacja x relop y jest prawdą, wysyłamy do MUX, znajdującego się przed zegarem, sygnał, aby przejść do wskazanego adresu PC+L, w przeciwnym wypadku korzystamy z adresu PC+4.

## Zadanie 5
:::success
Autor: Kacper Komenda
:::

Jump podobnie jak na rysunku, adresy PC są przechowywane tak, że jest wielokrotnością 4. Następne 26 bity bierzemy z naszej stałej, a pozostałe 4 z poprzedniej wartości PC

W przypadku x = y binop imm nie trzeba dodawać hardware'u. Zmienia sie tylko kontrola, cała ścieżka przepływu wygląda podobnie jak w zadanu 3, jednak w Register File używamy dwóch zmiennych y potem przejdzie dalej, a x do zapisu. Zamiast zmiennej z mamy stałą, która zostanie poprowadzona przez Sign Extend i multiplekser do ALU

## Zadanie 6
:::success
Autor: Jacek Długopolski
:::

## Zadanie 7
:::success

Autor: Patryk Mazur
:::

$[ps]$

$T_c(x=*(y+imm))$ = PC + Inst. Memory + $max$(Sign extend + MUX, Register file) + ALU + Data memory + MUX + Register file
$T_c(x=*(y+imm)) = 50 + 250 + max(50,25,150)+200+250+25+150 = 1075$

$T_c(*(x+imm)=y)$ = PC + Inst. Memory + $max$(Sign extend + MUX, Register file) + ALU + Data Memory
$T_c(*(x+imm)=y) = 50 + 250 + max(150,25+50) + 200+ 250= 900$

$T_c(if \,\, x\,\, relop\,\, y\,\, goto \,\,L)$ = PC + Inst. Memory $max$(Register file + MUX + ALU, Sign Extend + Adder) + MUX + MUX
$T_c(if \,\, x\,\, relop\,\, y\,\, goto \,\,L) = 50+250+ max(150+25+200,50+150)+25+25 = 725$

$T_c(x\, = y \,\,binop\,\, z)$ = PC + Inst. Memory + Register File + MUX + ALU + MUX + Register File
$T_c(x\, = y \,\,binop\,\, z) = 50+250+150+25+200+25+150 = 850$

Długośc cyklu = $max(850,900,1075,725) = 1075$
W podstawowym procesorze długość cyklu($x$) jest zawsze równa 1075 (długość najdłuższej instrukcji)
$y$ - Długość cyklu w "ulepszonym" procesorze
$x = 1075$
$y = 25\% \cdot 1075 +11\% \cdot 900 + 12\% \cdot 725 + 52\% \cdot 850 = 896.75$
$y/x = 0.8341$
$100\% - y/x = 16.5\%$

Osiągniemy przyspieszenie na poziomie ~ 16.5%

## Zadanie 8
:::success
Autor: Filip Komorowski
:::



## Zadanie 9
:::success
Autor: Emil Kisielewicz
:::


## Zadanie 10
:::success
Autor: Szymon Mleczko
:::


Dodajemy swapa między ALUResult i Wruite_data:
instm -> Reg_flile -> [y= RD1| x= RD2| imm = Sign ]-> alu(y+imm) -> Swap(AluResult = x; Write_data=y+imm)-> Data_mem

## Zadanie 11
:::success
Autor: Piotr Piesiak
:::
$T_c(x=*(y+imm)) = 50 + 250 + max(50,25,150)+200+250+25+150 = 1075$
$T_c(*(x+imm)=y) = 50 + 250 + max(150,25+50) + 200+ 250= 900$
$T_c(x\, = y \,\,binop\,\, z) = 50+250+150+25+200+25+150 = 850$

W poprzednim procesorze długość cyklu: $C_t = 1075 ps$
W nowym procesorze długość cyklu: $C_t' = 875 ps$

Poprzedni procesor potrzebował dokładnie $C_t$, aby wykonać jedną instrukcję z oryginalnego kodu (kompilacja nie powodowała zmian w instrukcjach).

Zmodyfikowany procesor może dostać więcej instrukcji niż w oryginalnym kodzie, zatem jego średni czas wykonania jednej instrukcji możemy obliczyć jako średnią ważoną, gdzie $\alpha$ to procent instrukcji korzystających z pamięci:
$(1 - \alpha) * C_t' + 2 * \alpha * C_t' = C_t' * (1 + \alpha)$

Zauważmy, że zmodyfikowany procesor będzie szybszy od poprzedniego wtw.
$C_t'(1+\alpha) < C_t$, czyli
$\alpha < \frac{C_t}{C_t'} - 1$
$\alpha < 0,229$

W podanej specyfikacji z zadania 7, instrukcje dostępu do pamięci zajmują 11% + 25% = 36%. Ponieważ $0,36 > 0,229$, zmodyfikowany procesor wykona taki program wolniej.