Petit bench en C pour tester la performance d'un processeur
Bonjour a tous,
Je sollicite votre aide car je me retrouve bloquee et malgre de nombreuses recherches sur le net, je n'ai rien trouve qui puisse resoudre mon probleme.
Je cherche a realiser un pti code tout simple mettant en oeuvre le calcul du produit d'une matrice carree et d'un vecteur (de flottants) et le temps d'execution. Seulement, j'ai quelques imperatifs :
ne faire qu'un seul gros malloc pour la matrice et les 2 vecteurs.
faire varier la taille des matrices et vecteurs, pour pouvoir etudier l'evolution des performances.
Je repete egalement le calcul un certain nb de fois pour rendre le timer pertinent.
Voici le code :
Code:
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
| #include <sys/time.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
int N;
int main(void) {
int j,k,l;
double* tab;
struct timeval t1;
struct timeval t2;
struct timezone tz1;
long int diff;
for (l=1;l<=1100;l+=2){
fflush(stdin);
N = l;
tab = malloc((N+2)*N*sizeof(double));
/* initialisation des tableaux */
for (j=0; j<(N+1)*N; j++) {
tab[j]=drand48();
}
/* appel de la routine */
gettimeofday(&t1,&tz1);
for (k=0;k<10000;k++) {
routine(tab,tab+(N*N),tab+(N+1)*N);
}
gettimeofday(&t2,&tz1);
diff = (t2.tv_sec-t1.tv_sec) * 1000000 +((t2.tv_usec) - (t1.tv_usec));
printf("%d;%d\n", N, diff);
}
}
#include <stdlib.h>
#include <stdio.h>
extern int N;
void routine(double A[], double B[], double C[]){
int i,j;
for(i=0;i<N;i++) {
for (j=0; j<N; j++) {
C[i] = C[i] + A[(i*N)+j] * B[j];
}
}
} |
Je fais 2 fichiers car je les compile avec des options d'optimisation differentes.
Le probleme est que le programme n'arrive pas jusqu'a la fin : il se termine automatiquement a la moitie de l'execution. De plus, il met plus d'une heure a le faire du coup les MFLOPS obtenues sont tres insatisfaisants par rapport a l'architecture du processeur.
Avez-vous une petite idee de ce qui cloche dans mon programme ?
Merci d'avance pour votre aide ! ;-)
Re: Petit bench en C pour tester la performance d'un process
Citation:
Envoyé par mystia
Je cherche a realiser un pti code tout simple mettant en oeuvre le calcul du produit d'une matrice carree et d'un vecteur (de flottants) et le temps d'execution. Seulement, j'ai quelques imperatifs :
ne faire qu'un seul gros malloc pour la matrice et les 2 vecteurs.
faire varier la taille des matrices et vecteurs, pour pouvoir etudier l'evolution des performances.
Je repete egalement le calcul un certain nb de fois pour rendre le timer pertinent.
Voici le code :
Je fais 2 fichiers car je les compile avec des options d'optimisation differentes.
C'est permi ça ?
Citation:
Le probleme est que le programme n'arrive pas jusqu'a la fin : il se termine automatiquement a la moitie de l'execution. De plus, il met plus d'une heure a le faire du coup les MFLOPS obtenues sont tres insatisfaisants par rapport a l'architecture du processeur.
Avez-vous une petite idee de ce qui cloche dans mon programme ?
Pas mal de choses :
- Ton code n'est pas portable, ce qui est une très mauvaise idée pour réaliser un bench censé fonctionner sur n'importe quelle architecture.
- L'effet de fflush (stdin) n'est pas défini et pourrait très bien provoquer n'importe quoi (comme ralentir ton code).
- Le resultat de malloc() n'est pas testé.
- Le bloc alloué n'est jamais libéré.
- J'ai quelques doutes quand à la validité des calculs d'index (non vérifié) attention aux débordements éventuels...
Essaye ça:
Code:
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
size_t N;
void routine (double A[], double B[], double C[])
{
size_t i;
for (i = 0; i < N; i++)
{
size_t j;
for (j = 0; j < N; j++)
{
C[i] = C[i] + A[(i * N) + j] * B[j];
}
}
}
int main (void)
{
size_t l;
for (l = 1; l <= 1100; l += 2)
{
N = l;
{
size_t n = (N + 2) * N;
double *tab = malloc (n * sizeof *tab);
if (tab)
{
size_t j;
/* initialisation des tableaux */
for (j = 0; j < n; j++)
{
tab[j] = rand ();
}
/* appel de la routine */
{
clock_t t1 = clock ();
unsigned k;
for (k = 0; k < 10000; k++)
{
routine (tab, tab + (N * N), tab + (N + 1) * N);
}
{
clock_t diff = (clock () - t1);
printf ("%lu;%lu ticks (%u tests)\n"
, (unsigned long) N
, (unsigned long) diff
, k
);
}
}
free (tab);
}
else
{
printf ("Out of memory. Test stopped\n");
}
}
}
return 0;
} |
