Discussion :

[mystia]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ! ;-)

[Emmanuel Delahaye]

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 ?

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[mystia]

Ca y est j'ai enfin reussi a faire marcher mon bench.
Mes problemes étaient principalement dus aux erreurs que tu as remarqué.
Et je t'en remercie beaucoup.

En ce qui concerne le fait que le programme se terminait tout seul, cela était aussi due a la taille maximale que je voulais allouer : elle depassait la quantite de memoire vive disponible. J'ai fait un peu de place, revu mes tailles a la baisse, et maintenant tout marche bien.

En tout cas, je te remercie encore de m'avoir consacré un peu de temps, ce qui me fut fort utile.



Ah ! et pour le fait d'avoir 2 fichiers avec des options de compilation différentes, je fais tout ca dans un Makefile sur conseil de mon prof .... Et ca n'a pas l'air de poser pb. Apres fo voir les codes qui sont generes par le compilo.
Voilou.

[mystia]

Par contre, j'aurai juste une petite question :
Pourquoi declares-tu les compteurs en size_t plutot qu'en int ?
Est-ce pour l'acces memoire au tableau ?

[Emmanuel Delahaye]

Pourquoi declares-tu les compteurs en size_t plutot qu'en int ?
Est-ce pour l'acces memoire au tableau ?

Oui. size_t est le type retourné par l'opérateur sizeof. Il sert à contenir des valeurs comme la taille d'un objet, et donc tout naturellement aux indices de tableaux. Rien ne dit qu'un objet de type int soit adapté à ce travail.