Øvelse+10+-+Cache

= Øvelsen = I denne øvelse har vi lavet to programmer: __Sekventiel__ code format="c"
 * 1) include 
 * 2) include 

int main {   const int N = 400; int i,j,k; double res[N][N], mul1[N][N], mul2[N][N];

double tmp[N][N]; for(i = 0; i < N; ++i) for(j = 0; j < N; ++j) tmp[i][j] = mul2[j][i]; for(i = 0; i < N; ++i) for(j = 0; j < N; ++j) for(k = 0; k < N; ++k) res[i][j] += mul1[i][k] * tmp[j][k]; printf("Done - Seq"); return 0; } code

__Ikke Sekventiel__ code format="c"
 * 1) include 
 * 2) include 

int main {  const int N = 400; double res[N][N], mul1[N][N], mul2[N][N]; int i,j,k;

for(i = 0; i < N; ++i) for(j = 0; j < N; ++j) for(k = 0; k < N; ++k) res[i][j] += mul1[i][k] * mul2[k][j]; printf("Done - not seq"); return 0; } code

Programmerne kompileres i første omgang til host. Dette gør vi på følgende måde:
gcc -O1 -o 


 * gcc - er kompileren
 * -O1 er optimerings-parametere
 * -o  navnet på filen, efter den er kompilet
 * er hvilken fil der skal kompiles

Forklaring af real, user og sys tider

 * real-tid: Den totale eksekveringen som programmet tager. real-tid = user-tid + sys-tid
 * user-tid: Hvor lang tid eksekveringen af programmet tager.
 * sys-tid: Kerne tid. Hvor lang tid det tager at hente dataen.

Eksekveringstiden for de forskellige metoder noteres og der laves en sammenligning. Hvad virker bedst og hvorfor?
Vi har kørt programmerne 7 gange, og har noteret tiderne af sys og derefter taget gennemsnittet. Tiderne er målt i sekunder. Som det ses er den sekventielle kode hurtiger over flere tidsmålinger end den ikke-sekventielle kode. Dette skyldes at hver gang cachen indlæser, indlæser den 4 words af gangen. Den sekventielle kode læser fra word 0-10 og så frem deles. Den ikke-sekventielle kode læser word1-word11-word21 osv. Derfor er dette langsommere, da det data der skal bruges ikke ligger i cachen som det er tilfældet i sekventiel kode. Billedet nedenunder illustrere dette:
 * Ikke Sekventiel || Sekventiel ||
 * 0.233 || 0.071 ||

Et par overvejelser/hints til implementeringen:
• Vælg en fornuftig størrelse af dine matricer ex 100x100. Hvad kan problemet være ved at vælge f.eks en 1000x1000 matrice? Hvis der vælges en matrice med 1000, opstår der en fejl. Vi har brugt en matrice på 400.

Vi har kompileret koden med de 4 optimerings-parametere. Ved eksekveringen af kodestumperne har det vist sig ved samtlige tidsmålinger, at den sekventielle kode er hurtigere end den ikke-sekventiel kode. Disse fire bruges ved at skrive:
 * -O0 - Reducer kompileringstid . Dette er standard.
 * -O1 -  Optimer
 * -O2 -  Optimer mere
 * -O3 - Optimer endnu mere.

[|optimering af gcc]