---
# System prepended metadata

title: BSC LAB 5

---

# BSC LAB 5

### Autorzy

* Maciej Włodarczyk
* Marcin Dadura
* Krzysztof Zdulski

## Cel laboratorium

Laboratorium polegało na zaznajomieniu się z SystemC. W tym celu należało zmodyfikować kod liczący 3 potęgę, aby liczył 4 potęgę. Następnie należało wykonać syntezę oraz testy i symulację.

## Untimed

Pierwsza wersja jest najprostsza. Nie zawiera zadnym mechanizmów synchronizacji.

Jedyną zmianą jest długość wektorów na 16bit z 8bit oraz dodanie dodatkowej iteracji pętli.

##### Zmiany w pliku power3.h

```diff=
- sc_in<sc_uint<8> > Xin;
- sc_out<sc_uint<8> > XPower;
+ sc_in<sc_uint<16> > Xin;
+ sc_out<sc_uint<16> > XPower;
- sc_uint<8> X, result;
+ sc_uint<16> X, result;
.
.
.
- for (i=0;i < 3; i++)
+ for (i=0;i < 4; i++)
```

#### Zmiany w pliku main_power3.cpp


```diff=
-sc_signal<sc_uint<8> > X ("X"),result ("result");
+sc_signal<sc_uint<16> > X ("X"),result ("result");
```


##### Symulacja

Początkowo symulacja przebiegła nieprawidłowo. Ponieważ `5**4 = 625` potrzebujemy więcej niż 8 bitów w zmiennej rezultatu.

Przed zmianą z 8bit na 16bit:

![](https://hackmd.io/_uploads/ByJ2epJBn.png)

Widzimy, że resultat overflowuje (`113 = 625 % 256`)

Po zmianie:

![](https://hackmd.io/_uploads/H1ozW61S2.png)

![](https://hackmd.io/_uploads/BkRd-6JB2.png)

![](https://hackmd.io/_uploads/HJNo-a1rn.png)


## Loosly timed

Następna iteracja zakładana dodanie dodatkowej pętli. Model zawiera zależności czasowe, które określają relacje pomiędzy kolejnymi porcjami danych.



Jedyną zmianą jest długość wektorów na 16bit z 8bit oraz dodanie dodatkowej iteracji pętli.


##### Zmiany w pliku power3_lt.h

```diff=
- for (i=0;i < 3; i++)
+ for (i=0;i < 4; i++)
```

##### Zmiany w pliku main_power3_lt.cpp

```diff=
-sc_signal<sc_uint<8> > X ("X"),result ("result");
+sc_signal<sc_uint<16> > X ("X"),result ("result");
```


##### Symulacja

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


## Timed functional

Pojawia się synchronizacja zegarem (SC_CTHREAD)
oraz dodatkowe sygnały handshakingowe. Obliczenia wykonywane są w jeden takt.


Jedyną zmianą jest długość wektorów na 16bit z 8bit oraz dodanie dodatkowej iteracji pętli.

##### Zmiany w pliku power3_tf.h

```diff=
- for (i=0;i < 3; i++)
+ for (i=0;i < 4; i++)
```


##### Zmiany w pliku main_power3_tf.cpp

```diff=
-sc_signal<sc_uint<8> > X ("X"),result ("result");
+sc_signal<sc_uint<16> > X ("X"),result ("result");
```


##### Symulacja

![](https://hackmd.io/_uploads/B1kufaJB2.png)


## Latency

Model ten zawiera sterowanie latencją. Model synchronizuje zegar, a operację za pomocą `wait()` nie są wykonywane za jednym zamachem, a co takt. Operacja wymaga teraz 5 taktów.


W tym przypadku zmiany oprocz długości wektorów obejmują dopisanie kolejnej iteracji rozwiniętej pętli w celu zwiększenia ilości potęgi.


##### Zmiany w pliku power3_latency.h

```diff=
-    sc_in<sc_uint<8> > Xin;
-    sc_out<sc_uint<8> > XPower;
-    sc_uint<8>  X, result; 
+    sc_in<sc_uint<16> > Xin;
+    sc_out<sc_uint<16> > XPower;
+    sc_uint<16>  X, result; 
.
.
.
		X = Xin.read();
		wait();
		result = X*result;
		XPower.write(result);
		wait();
		result = X*result;
		XPower.write(result);
		wait();
		result = X*result;
		XPower.write(result);
-    }
+		wait();
+		result = X*result;
+	    XPower.write(result);
+	}
```

##### Zmiany w pliku main_power3_latency.cpp

```diff=
-sc_signal<sc_uint<8> > X ("X"),result ("result");
+sc_signal<sc_uint<16> > X ("X"),result ("result");
.
.
.
X.write(6);
sc_start(6, SC_NS);
cout<<"input "<< X<<endl;
cout<<"output "<<result<<endl;
-sc_start(12, SC_NS);
+sc_start(36, SC_NS);
sc_stop();
return(0);
```


##### Symulacja

![](https://hackmd.io/_uploads/Sym6Z61Bn.png)

## Pipe

Pierwsze obliczenie i wczytanie danych odbywa się w tym samym takcie. Dodatkowo za sprawą potokowania wykonywane operację mogą być równolegle. To znaczy po wczytaniu pierwszej liczby i pomnozeniu jej, w następnym takcie jesteśmy w stanie przyjąć kolejną liczbę. 



Zmiany obejmują utworzenie kolejnego rejestru pośredniego oraz dopisaniu kolejnej operacji w celu otrzymania 4 potęgi.


##### Zmiany w pliku power3_pipe.h

```diff=
- sc_in<sc_uint<8> > Xin;
- sc_out<sc_uint<8> > XPower;
- sc_uint<8> pX1, pX2, pX3, presult1, presult2, presult3 ;
- sc_signal <sc_uint<8> > X, X1, X2,result1, result2, result3;
+ sc_in<sc_uint<16> > Xin;
+ sc_out<sc_uint<16> > XPower;
+ sc_uint<16> pX1, pX2, pX3, pX4, presult1, presult2, presult3, presult4 ;
+ sc_signal <sc_uint<16> > X, X1, X2, X3, result1, result2, result3, result4;
.
.
.
			result3 = presult3;
-			XPower.write(presult4);
+			X3=X2;
+			presult3 = result3;
+			pX3 = X3;
+			presult4 = pX3 * presult3;
+			result4 = presult4;
+			XPower.write(presult4);
```

##### Zmiany w pliku main_power3_latency.cpp

```diff=
-sc_signal<sc_uint<8> > X ("X"),result ("result");
+sc_signal<sc_uint<16> > X ("X"),result ("result");
sc_signal <bool> start ("start");
-sc_clock clk ("clock",4,SC_NS,0.5,1,SC_NS,true);
+sc_clock clk ("clock",3,SC_NS,0.5,1,SC_NS,true);
.
.
.
X.write(5);
-sc_start(4, SC_NS);
+sc_start(5, SC_NS);
X.write(2);
```


## Podsumowanie

Dzięki laboratorium udało nam się zapoznać z SystemC oraz sposobami przyśpieszenia, synchronizacji oraz potokowanie obliczeń wykonywanych cyfrowo.