Commit 82eb6b2c authored by Christoph Gerum's avatar Christoph Gerum

Blatt02

parent 8701693c
Title: Blatt 2
status: hidden
# Superskalare Architekturen (**DRAFT**)
## Aufgabe 1
Der gem5 Simulator bietet die Möglichkeit, die Ausführung auf der virtualisierten Pipeline zu visualisieren. Dazu werden vom Simulator während der Ausführung Debug-Ausgaben gespeichert, die wiederum für die Erstellung einer übersichtlichen Darstellung verwendet werden.
# Superskalare Architekturen
Ziel dieser Aufgabe ist es, dass Sie sich mit der grundlegenden Funktionalität des Pipeline-Viewers vertraut machen. Zu diesem Zweck steht in ILIAS der Quellcode einer einfachen DAXPY-Loop bereit, den sie auf dem Simulator ausführen sollen. Anschließend können sie das tracefile mit dem mitgelieferten pipeview-Tool umwandeln und mit less anschauen.
Vor der Bearbeitung des Blatts ```git pull``` im Verzeichnis mit den Aufgaben ausführen (```parallel_computer_architecture/exercises/``` auf der VM).
## Aufgabe 1: Scoreboarding / Register Renaming
In diesem Übungsblatt wird die out-of-order Ausführung auf der Pipeline der [```O3CPU```](http://www.m5sim.org/O3CPU) genauer betrachtet.
Die Pipeline der ```O3CPU``` hat die folgenden 5 Stufen:
1. Fetch: Holt Befehle aus dem *Instruction Cache*.
2. Decode: Dekodiert Befehle. Kann ausserdem unbedingte, direkte Sprungbefehle ausführen ohne die execute Stufe zu benutzen.
3. Rename: Implementiert dynamisches Register Renaming. Dabei werden die von den Befehlen verwendeten Architektur Register dynamisch auf ein größeres physical Register File abgebildet.
4. Issue/Execute/Writeback: Implementiert eine Variante des aus der vorlesung bekannten Scoreboard-Algorithmus.
5. Commit: Implementiert einen *Inorder Commit*.
Der gem5 Simulator bietet die Möglichkeit, die Ausführung auf der virtualisierten Pipeline zu visualisieren. Dazu werden vom Simulator während der Ausführung Debug-Ausgaben gespeichert, die wiederum für die Erstellung einer übersichtlichen Darstellung verwendet werden. Anschließend können sie das tracefile mit dem mitgelieferten pipeview-Tool umwandeln und mit dem Programm less darstellen.
In der Datei ```mul/multiplication.c``` im Verzeichnis dieses Aufgabenblatts befindet sich ein einfaches Programm, dass die folgende Funktion ausführt.
```{.c}
void mult(int* x, int* y, int a, int n)
{
int i;
for (i = 0; i < n; i++) {
y[i] = x[i] * y[i];
}
}
```
* Kompilieren Sie den Quellcode für den Simulator
* Führen Sie den Simulator aus, so dass die benötigten Ausgaben erzeugt werden:
``` build/ARM/gem5.opt --debug-flags=O3PipeView --debug-start=1 --debug-file=trace.out configs/example/se.py --cpu-type=detailed --caches -c ~/advanced_computer_architecture/exercises/blatt02/exec/daxpy ```
* Wandeln Sie das Trace um:
```./util/o3-pipeview.py -c 500 -o pipeview.out --color m5out/trace.out```
* Schauen Sie sich die Visualisierung an:
```less -r pipeview.out```
${GEM5_DIR}/build/ARM/gem5.opt --debug-flags=O3PipeView --debug-start=1 --debug-file=trace.out pipeline.py -c mul/multiplication.elf
* Wandeln Sie den Trace um:
${GEM5_DIR}/util/o3-pipeview.py -c 500 -o pipeview.out --color m5out/trace.out
Achten Sie beim umwandeln des Trace darauf, dass die angebene Cycle Time in Femtosekunden mit der Taktfrequenz der Simulation übereinstimmt. 500 enstpricht 2 GHz.
* Die Visualisierung lässt sich dann wie folgt darstellen:
less -r pipeview.out
Suchen Sie in der Pipelinevisualisierung die eine Ausführung der Schleife die möglichst schnell abläuft.
Ignorieren Sie insbesondere Zeilen die = statt . enthalten.
### Fragen:
1. Wie lange dauert die Ausführung der einzelnen der IEW-Stufe der Pipeline für die verschiedenen
Instruktionstypen.
2. Wo können Sie das verhalten des gem5 Scoreboards, mit der Beschreibung des Scoreboard-Algorithmus aus der Vorlesung in Einklang bringen?
3. Lassen sich einige der Abweichungen durch Register Renaming erklären.
4. Lassen sich einige der Abweichungen erklären, wenn man annimmt, dass die Ausführung in der IEW-Stufe bei ldr Befehlen 3 Takte dauern würde?
### Abgabe:
Antworten auf die Fragen.
## Aufgabe 2: Superskalare Befehlsausführung
Die Pipeline des gem5 lässt sich so konfigurieren, dass nicht nur in der ```Execute Stufe``` Instruktionen parallel ausgeführt werden können.
Dies wird über die width Parameter der einzelnen Stufen gesteuert. Passen Sie das Skript ```pipeline-py``` so an, dass das sich die breite der
Pipeline zwischen 1 und 8 per Kommandozeilenparameter variieren lässt.
Im Unterverzeichnis ```automotive``` finden Sie verschiedene Benchmarkprogramme.
Führen sie die folgenden Benchmarks aus für alle Breiten der Pipeline aus.
| Benchmark | Commando |
|----------------|------------------------------------------------------------------------------------------|
| basicmath | automotive/basicmath/basicmath_small |
| bitcnts | automotive/bitcount/bitcnts 75000 |
| qsort | automotive/qsort/qsort_small automotive/qsort/input_small.dat |
| susan_smooth | automotive/susan/susan automotive/susan/input_small.pgm output_small.smoothing.pgm -s |
| susan_edge | automotive/susan/susan automotive/susan/input_small.pgm output_small.edges.pgm -e |
| susan_contrast | automotive/susan/susan automotive/susan/input_small.pgm output_small.corners.pgm -c |
Erstellen Sie einen Plot in dem sich die Performance der simulierten Konfigurationen vergleichen lässt.
### Fragen:
1. Welche Konfiguration würden Sie wählen?
2. Zeigen manche der Benchmarks ein unerwartetes Verhalten?
### Abgabe:
Geben Sie einen Screenshot der Pipeline Ansicht ab.
Plots der Benchmarks und Antworten auf die Fragen.
\ No newline at end of file
all:
arm-linux-gnueabihf-gcc -static -O1 daxpy.c -o daxpy
o3:
arm-linux-gnueabihf-gcc -static -O3 daxpy.c -o daxpy
clean:
rm daxpy daxpy.s
/* #include<stdio.h> */
#define N 1000 // size of vector
#define R 1 // number of repetitions
// daxpy: Y = aX + Y (n size vector, a constant, X,Y vectors)
void daxpy(double* x, double* y, double a, int n)
{
int i;
for (i = 0; i < n; i++) {
y[i] = a * x[i] + y[i];
}
}
// pretty print vector
/* void print_vector(double* vec, int n) */
/* { */
/* int i; */
/* for (i=0; i<n-1; i++) { */
/* printf("%f,\t",vec[i]); */
/* } */
/* printf("%f",vec[n-1]); */
/* printf("\n"); */
/* } */
void main()
{
static double x[N], y[N];
double a = 5.5;
int i;
for (i = 0; i<N; i++) {
x[i] = 7.833667+i;
y[i] = 0;
}
/* print_vector(y, N); */
for (i = 0; i<R; i++) {
daxpy(x,y,a,N);
}
/* print_vector(y,N); */
}
all: multiplication.c Makefile
arm-linux-gnueabihf-gcc -static -O1 multiplication.c -o multiplication.elf
o3: multiplication.c Makefile
arm-linux-gnueabihf-gcc -static -O3 multiplication.c -o multiplication_o3.elf
clean:
rm daxpy daxpy.s
/* #include<stdio.h> */
#define N 1000 // size of vector
#define N 400 // size of vector
#define R 1 // number of repetitions
// daxpy: Y = aX + Y (n size vector, a constant, X,Y vectors)
void daxpy(int* x, int* y, int a, int n)
void mult(int* x, int* y, int a, int n)
{
int i;
for (i = 0; i < n; i++) {
y[i] = a * x[i] + y[i];
y[i] = x[i] * y[i];
}
}
// pretty print vector
/* void print_vector(double* vec, int n) */
/* { */
/* int i; */
/* for (i=0; i<n-1; i++) { */
/* printf("%f,\t",vec[i]); */
/* } */
/* printf("%f",vec[n-1]); */
/* printf("\n"); */
/* } */
void main()
{
......@@ -37,7 +27,7 @@ void main()
/* print_vector(y, N); */
for (i = 0; i<R; i++) {
daxpy(x,y,a,N);
mult(x,y,a,N);
}
/* print_vector(y,N); */
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment