---
# System prepended metadata

title: 'Ćwiczenia 6, grupa śr. 12-14, 3 kwietnia 2024'
tags: [pwit, ćwiczenia, SYK24]

---

# Ćwiczenia 6, grupa śr. 12-14, 3 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  |
| ----------------------:| -----| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | 
Mikołaj Balwicki         |   x  |  x   |  x   |  x   |  x   |  x   |     |     |     |     |     |  
Małgorzata Galińska      |   X   |   X  |  X   |   ==X==  |  X   |     |     |  X   |     |  X   |     |
Maria Hreniak            |   X   |   X  |   X  |     |     |     |     |  X  |     |  X  |     |
Jakub Jankowski          |    X  |  X   |   X  |   X  |  X   |  X   |  X   |  X   |  X   |  X   |  X   |
Mikołaj Kalitka          |      |     |     |     |     |     |     |     |     |     |     |
Julia Konefał            |   X   |  X   |  X   |  X   |     |     |     |     |     |     |     |
Julia Kulczycka          |   X   |  ==X==  |   X  |   X  |  X   |  X   |  X   |  X   |  X   |  X   |  X   |
Cecylia Łyjak            |  ==X==    |  X   |   X  |     |     |     |     |   X  |     |     |     |
Adam Majchrowski         |   X   |  X   |  X   |  X   |  X   |   ==X==  |     |   X  |     |  ==X==   |     |
Piotr Mańkowski          |   X   |   X  |  X  |   X  |     |     |     |     |     |     |     |
Piotr Salamon            | X     |  X   | ==X==    |  X   |     |  X   |  X   |  X   |   X  |  X   |     |
Maciej Szałasz           |   ==X==   |  X   |   X  |  X   |   X  |   X  |  X   |  X   |   X  |    X |   X  |
:::

Poniżej można zadeklarować **zadanie 5** z **listy 5**:

:::success
|                        | 5.5  | 
| ----------------------:| -----|
Mikołaj Balwicki         |      |  
Małgorzata Galińska      |      |
Maria Hreniak            |      |
Jakub Jankowski          |      |
Mikołaj Kalitka          |      |
Julia Konefał            |      |
Julia Kulczycka          |      |
Cecylia Łyjak            |      |
Adam Majchrowski         |      |
Piotr Mańkowski          |      |
Piotr Salamon            |      |
Maciej Szałasz           |      |
:::





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



## Zadanie 1
:::success
Autor: 	Cecylia Łyjak	
:::
![Zrzut ekranu 2024-04-2 o 21.49.49](https://hackmd.io/_uploads/B1KPZ15k0.png)

1. Odczytanie numeru instrukcji oraz dekodowanie informacji - odczytanie numeru rejestru y, rozszerzenie imm do 32 bitów, przekazanie informacji do Control Unit. 

![Zrzut ekranu 2024-04-2 o 21.52.30](https://hackmd.io/_uploads/r15WGk9JA.png)

2. Przekazanie informacji o dodawaniu do ALU, odczytanie wartości rejestru y i przekazanie jej wraz z imm do dodawania. 
![Zrzut ekranu 2024-04-2 o 21.56.08](https://hackmd.io/_uploads/BkNkm1q1A.png)

3. Policzenie sumy w ALU, przekazanie do Data MEmory do odczytu i przekazanie wartości do Register File by wartość zapisać w rejestrze x.

![Zrzut ekranu 2024-04-2 o 22.06.59](https://hackmd.io/_uploads/BJedSyqy0.png)

## Zadanie 2
:::success
Autor: 	Julia Kulczycka	
:::
Operacja polega na wpisaniu do pamięci wartości y pod adresem $x + imm$.

1. Przekazanie numeru instrukcji do rejstru rozkazów.
2. Oczytanie instrukcji przez rejestr rozkazów i przesłanie inforacji o niej do pliku rejestrów, oraz informacji, ze bedzie wykonywac dodawanie do ALU.
![image](https://hackmd.io/_uploads/BkN7wqqy0.png)
3. Odczytanie wartości zmiennych $x$ i $y$ przez rejestr plików i przesłanie wartości $x$ do ALU, a wartości $y$ do pamięci.
![image](https://hackmd.io/_uploads/BJdsvc5JR.png)
4. Rozszerzenie reprezentacji $imm$ do 32-bitów, zeby mozna było ją dodać do $x$.
5. Przekazanie $x$ oraz $imm$ do ALU, gdzie zostaną dodane.
![image](https://hackmd.io/_uploads/BJkw_q9kA.png)
6. Zapisanie wartości $y$ w pamięci pod wyliczonym w ALU adresem. (bo $y$ jest na WriteData, $x + imm$ to A- Address, oraz MemWrite jest ustawiony na 1, czyli zapisujemy dane)
![image](https://hackmd.io/_uploads/HJumYcqkR.png)

## Zadanie 3
:::success
Autor: 	Piotr Salamon	
:::
![image](https://hackmd.io/_uploads/SytoaW5yC.png)
1: Pobranie instrukcji. Przekazanie y oraz z do Register File gdzie odczytane zostają ich wartości. Następuje przejście przez Control Unit i ustawienie ALU na odpowiednią operację.
2: X zostaje przekazany do multipleksera a następnie zajmuje miejsce A3 czekając na swoją wartość WD3
3: Na wartościach y i z następuje operacja binarna z użyciem ANU.
4: Wynik operacji przechodzi przez multiplekser.
5: Wynik operacji wchodzi w miejsce WD3 i wartość x zostaje zamisana z wyliczoną wartością.

## Zadanie 4
:::success
Autor: 	Małgorzata Galińska	
:::
![image](https://hackmd.io/_uploads/rJ0pCoqkR.png)
![image](https://hackmd.io/_uploads/BkU40jqyC.png)
1.	Z licznika rozkazów (pudełko z PC’, CLK, PC) pobierany jest numer aktualnego rozkazu i przekazywany do Instruction Memory
2.	W Instruction Memory wyszukiwana jest instrukcja z pamięci i przekazywana dalej (przekazywany jest numer rejestru x do A1 i numer rejestru y do A2)
3.	W Sign Extend adres L jest rozszerzany do 32 bitów (w naszym modelu możemy odczytać tylko 2 rejestry, więc nie zapiszemy L w rejestrze, więc L jest zakodowany w instrukcji, jest stałą)
4.	Control Unit ustawia odpowiednie wartości ALUSrc (wartość 0), ALUControl (relop) oraz Branch (wartość 1).
5.	W Register File przekazywana jest wartość rejestru x oraz y do ALU
6.	W bloku ALU wyliczana jest wartość x relop y, jeśli zachodzi „Zero”, to wartość bramki AND to 1 i jest wykonywany skok
7.	Adres L przesuwany jest w lewo o 2 (musi być podzielny przez 4 i nie potrzebujemy pamiętać dwóch ostatnich zer, tylko je doklejamy poprzez przesunięcie, dzięki temu zawsze oszczędzamy 2 bity) i sumowany z aktualnym PC
8.	Jeśli warunek został spełniony, to wykonywana jest instrukcja PC+L, w przeciwnym przypadku kolejna instrukcja (PC+4)


## Zadanie 5
:::success
Autor: 	Mikołaj Balwicki
:::
![image](https://hackmd.io/_uploads/BJyNCs5JR.png)
![image](https://hackmd.io/_uploads/rkV2e29y0.png)
![image](https://hackmd.io/_uploads/By6WQ25kA.png)



## Zadanie 6
:::success
Autor: 	Jakub Jankowski	
Przechodzimy najdłuższymi ścieżkami którymi przepływaja dane (z poprz. zadań) i sumujemy czas wykonania dla odwiedzonych komponentów.
![image](https://hackmd.io/_uploads/HJmmkeExA.png)

minimalna dlugość cyklu zegara dla tego procesora (= max czas wykonania instrukcji) wynosi 1075ps
:::

## Zadanie 7
:::success
Autor: 	Maciej Szałasz	
:::
#### Czasy działania analizowanych instrukcji

- **$x = *(y+ imm)$** : $1075ps$
- **$*(x + imm):= y$** : $1075ps$
- **$if \; x \; relop \; y \; goto \; L$** : $675ps$
- **$x = y \; binop \; z$** : $825ps$

#### Czas działania procesora z zadania 6.

Maksymalna cyklu dla procesora z poprzedniej listy wynosiła $1075ps$. Więc, jeżeli wszystkie cykle mają stały czas to musi on wynosić przynajmniej $1075ps$.

#### Obliczenia

Wtedy czas działania programu dla procesora z zadania 6. wynosi $1075ps$.

Mając do dyspozycji procesor obsługujący różne długości dla każdej instrukcji,
otrzymujemy czas działania równy:

```
(0.25 * 1075ps + 0.11 * 1075ps + 0.12 * 675ps + 0.52 * 825ps) =
(268,75 + 118,25 + 81 + 429) =
897ps
```

Stosunek wartości:

```
1075 -897 = 178
178 / 1075 = 0.17
```

#### Przyśpieszenie

Wykonując identyczny program na procesorze o możliwych różnych długościach cyklu uzyskamy przyśpieszenie rzędu $17\%$.

## Zadanie 8
:::success
Autor: 	Maria Hreniak	
:::
![image](https://hackmd.io/_uploads/r10B0oqkA.png)
![image](https://hackmd.io/_uploads/ryZ_AsqyR.png)


1) Pobieramy numer instrukcji, na wyjściu z Instruction Memory
 dostajemy zdekodowaną instrukcje.
2) A1 ustawiamy na numer rejestru y
    A2 ustawiamy na numer rejestru z
    A3 ustawiamy na numer rejestru x (tak samo jak w zad3)
3) Control Unit daje nam:
ALUControl +
RegDst 1 (bo na tych bitach jest x)
MemtoReg 1 (o będziemy odczytywać z pamięci)
RegWrite 1 (bo ta instrukcja będzie zapisana w rejestrze x)
4) W ALU operacja dodawania y+z
5) W Register File zapisujemy wartość y+z, która jest w WD3 w adresie A3 (rejestr x).
6) teraz aktualizujemy licznik instrukcji, PC+4 bajty (bo każda instrukcja ma 32 bity)



## Zadanie 9
:::success
Autor: 	Piotr Salamon	
:::
Obecnie możemy odczytać wartości 2 zmiennych jednak nie możemy zapisać w jednym cyklu dwóch nowych wartości do zmiennych.

Należałoby roszerzyć układ o wejcia A4 i WD4 oraz WE3.
Można też połączyć bezpośredio RD z WD aby

Wtedy ścieżka to:
x do A1
y do A2
RD1 do WD3
RD2 do WD4
y po przejściu przez multiplekser do A3
x po przejściu przez multiplekser do A4

## Zadanie 10
:::success
Autor: 	Adam Majchrowski
![image](https://hackmd.io/_uploads/B1p41hck0.png)
![image](https://hackmd.io/_uploads/rkhBJn5JC.png)
:::

## Zadanie 11
:::success
Autor: 	Jakub Jankowski	
#### Zamiana instrukcji  $x = *(y + imm)$

- Obliczanie $t = y + imm$ (zajmuje 825ps).
- Przypisanie $x = *t$.

```
PC -> IM -> RF -> DM -> MX -> RF

T_c = 50 + 250 + 150 + 250 + 25 + 150 = 875
```

#### Zamiana instrukcji $*(x + imm) = y$

- Obliczanie $t = x + imm$ (zajmuje 825ps).
- Przypisanie $*t = y$.

PC -> IM -> RF -> DM

T_c = 50 + 250 + 150 + 250 = 700

#### Nowa długość cyklu

Po wykonaniu powyższych zmian maksymalna długość cyklu wynosi $875$ (w przypadku operacji $x = *t$).

#### Nowe czasy działania

Teraz instrukcje $x = *(y + imm)$ oraz $*(x + imm) = y$ wymagają dwóch cykli zamiast jednego.

#### Obliczenia

Czas działania starego procesora: $1075$

Czas działania nowego procesora:

```
(2 * 0.25 + 2 * 0.11 + 0.12 + 0.52) * 875 =
= 1.36 * 875 = 1190
```

Stary procesor jest więc szybszy dla programów o danej charakterystyce.

Jednakże, dla programów, w których operacje na pamięci są mniej częste, czas działania nowego procesora wynosi:

```
(2 * 0.05 + 2 * 0.05 + 0.2 + 0.7) * 875 =
= 1.1 * 875 = 962.5
```

W takim przypadku nowy procesor działa szybciej.
:::



