|
Passons au fichier main.c.
Nous devons allouer, désallouer, et chronométrer le temps que mettront certaines fonctions à s'exécuter, il nous faut donc les includes suivant :
1
2
3
|
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
|
Et bien sûr il faut aussi inclure le fichier calcul_cuda.h :
1
|
#include "calcul_cuda.h"
|
On fait une fonction qui initialise une variable pseudo-aléatoire :
1
2
3
4
|
void initRandom(){
time_t t = time(NULL);
srand(t);
}
|
Ensuite, une fonction qui renvoie un nombre aléatoire entre deux bornes :
1
2
3
|
float getRandFloat(float inf, float sup){
return inf + (((float)rand())*(sup - inf))/((float)RAND_MAX);
}
|
Puis, la fonction qui initialisera les matrices de manière aléatoire :
1
2
3
4
5
6
7
|
void initRandomMatrix(float* matrix, size_t size, float inf, float sup){
if(matrix == NULL) return;
size_t i,j;
for(i = 0; i < size*size; ++i){
matrix[i] = getRandFloat(inf, sup);
}
}
|
Et enfin, la fonction main, que l'on va faire en plusieurs morceaux.
Tout d'abord, on initialise l'aléatoire et on crée les variables qui nous servirons de chronomètre :
1
2
3
4
|
int main(int argc, char** argv){
initRandom();
clock_t temps = clock();
float chrono;
|
Ensuite on définit la taille des matrices :
1
2
|
int width = 100; int size = width*width*sizeof(float);
|
On déclare et on alloue ces matrices :
1
2
3
|
float * matriceLeft = malloc(size);
float * matriceRight = malloc(size);
float * matriceResult = malloc(size);
|
On initialise les matrices matriceLeft et matriceRight aléatoirement :
1
2
|
initRandomMatrix(matriceLeft, width, -10.0, 10.0);
initRandomMatrix(matriceRight, width, -10.0, 10.0);
|
On regarde le temps qu'on a mis pour faire tout ça, on l'affiche, et on redémarre le chrono :
1
2
3
4
|
temps = clock() - temps;
chrono = ((float)temps)/((float)CLOCKS_PER_SEC);
printf("Temps de l'initialisation : %fs\n", chrono);
temps = clock();
|
On appelle la fonction tant attendue :
1
|
matrixMulOnDevice(matriceResult, matriceLeft, matriceRight, width);
|
Et on regarde le temps qu'elle à mis :
1
2
3
|
temps = clock() - temps;
chrono = ((float)temps)/((float)CLOCKS_PER_SEC);
printf("Temps du calcul de la multiplication : %fs\n", chrono);
|
Enfin, on désalloue les matrices :
1
2
3
4
5
|
free(matriceResult);
free(matriceRight);
free(matriceLeft);
return 0;
}
|
Ouf, ça c'est fait.
Le fichier main.c en entier :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "calcul_cuda.h"
///fonction qui initialise le premier terme de la série pseudo-aléatoire
void initRandom(){
time_t t = time(NULL);
srand(t);
}
///fonction qui tire un nombre aléatoire entre deux bornes
float getRandFloat(float inf, float sup){
return inf + (((float)rand())*(sup - inf))/((float)RAND_MAX);
}
///fonction qui initialise une matrice carrée avec des nombres aléatoires
void initRandomMatrix(float* matrix, size_t size, float inf, float sup){
if(matrix == NULL) return;
size_t i,j;
for(i = 0; i < size*size; ++i){
matrix[i] = getRandFloat(inf, sup);
}
}
int main(int argc, char** argv){
initRandom();
clock_t temps = clock();
float chrono;
int width = 100; int size = width*width*sizeof(float);
float * matriceLeft = malloc(size);
float * matriceRight = malloc(size);
float * matriceResult = malloc(size);
initRandomMatrix(matriceLeft, width, -10.0, 10.0);
initRandomMatrix(matriceRight, width, -10.0, 10.0);
temps = clock() - temps;
chrono = ((float)temps)/((float)CLOCKS_PER_SEC);
printf("Temps de l'initialisation : %fs\n", chrono);
temps = clock();
matrixMulOnDevice(matriceResult, matriceLeft, matriceRight, width);
temps = clock() - temps;
chrono = ((float)temps)/((float)CLOCKS_PER_SEC);
printf("Temps du calcul de la multiplication : %fs\n", chrono);
free(matriceResult);
free(matriceRight);
free(matriceLeft);
return 0;
}
|
Vous pouvez le récupérer ici.
|