Temps d'exécution

Fermé
biba - 13 mars 2010 à 00:04
 biba - 14 mars 2010 à 20:04
Bonjour,
je suis en train d'étudier les performances du prog multiplication matricielle sur les architectures multi-coeurs. J'utilise dans mon prog une fonction clock get time pour me donner le temps ecoulé ds l'execution. Mon pb est que ce temps devient négatif des que je depasse la taille 500 de la matrice????????????
Merci d'avance.

5 réponses

dubcek Messages postés 18752 Date d'inscription lundi 15 janvier 2007 Statut Contributeur Dernière intervention 3 octobre 2024 5 618
13 mars 2010 à 08:01
helo
quelle matrice ?
0
Salut,
il s'agit d'une matrice allouée dynamiquement d'entiers ou de float ou de double.
0
dubcek Messages postés 18752 Date d'inscription lundi 15 janvier 2007 Statut Contributeur Dernière intervention 3 octobre 2024 5 618
13 mars 2010 à 17:28
si ton temps devient négatif, es-tu sûr d'utiliser le bon type de variable, int au lieu de long ?, par ex.
0
Salut,
j'utilise le type double pour le temps d'execution et meme je l'ai changé au long double, mais meme resultat:temps négatif des que la dimension de la matrice depasse 500.

double nsec;
struct timespec start, end;
//lecture du temp debut
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&start);
instruction;
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&end);// lecture du temps d'arret

nsec =(end.tv_sec * 1000000000 + end.tv_nsec) - (start.tv_sec * 1000000000 + start.tv_nsec) ;// calcul de l'intervalle
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 840
13 mars 2010 à 19:17
Il y a dépassement d'entiers.
Je pense qu'en multipliant par 1e9 au lieu de 1000000000, cela réglera le problème provisoirement.
Par la suite, il faudra vérifier si end.tv_sec >stard.tv_sec.

Cdlt,
0
Salut,
merci bien,votre solution m'as résolu mon problème, mais je veux bien savoir et comprendre la cause du temps négatif affiché, et la différence entre 1e9 et 1000000000.
Merci et j'attends votre réponse.
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 840
13 mars 2010 à 23:43
Ta variable end devrait contenir des nombres (seconde et nano-seconde) d'autant plus grands que le programme mettra du temps à s'exécuter. Le problème est que les secondes sont déclarées en time_t et les nano en long. Lorsque tu vas multiplier ton type time_t avec 1000000000, le C va considérer que c'est toujours du type time_t (donc du 'long' bien souvent). Sur une architecture 32 bits, il y aura dépassement lorsque la valeur dépassera 2^32-1 secondes. A ce moment-là, il repassera à -2^32. D'où le nombre négatif lorsque tu feras ta soustraction.
En remplaçant 1000000000 par 1e9, tu diras implicitement au compilateur de travailler en double. Et comme les limites sont beaucoup plus loin, le problème est réglé temporairement.

Cdlt,
0
Salut,
Merci bien pour vos eclaircissements.
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Salut,mon pb cette fois_ci ne concerne pas le temps d'exécution.Au contraire, je veux bien exploiter le calcul de ce temps dans le programme de la factorisationLU. En effet, j'ai ecrit un code en C mais mais malheureusement, il ne fournit pas des résultats justes toujours puisque dès qu'il tombe sur un pivot nul, le vecteur résultat est rempli de NAN. Ce qui est sur et certain que mon code lui manque des tests que je ne sais pas comment les mettre.
Pouvez vous m'aider s'il vous plait, ça concerne mon projet de fin d'étude.Voilà mon code:



/*La taille maximale de la matrice et pas d'incrementation*/
n=atoi(argv[1]);
inc=atoi(argv[2]);


for(dim=0; dim<=n; dim=dim+inc)
{
/*allocation des trois matrices */
a=(float*)malloc(dim*dim*sizeof(float));
y=(float*)malloc(dim*sizeof(float));
b=(float*)malloc(dim*sizeof(float));
/*Allocation du vecteur x */
x=(float*)malloc(dim*sizeof(float));


/*initialisation de la matrice a */
#pragma omp parallel for private(i,j)
for(i=0;i<dim;i++)
for(j=0;j<dim;j++)
a[i*dim+j]=i*j-1;

/* Initialisation du vecteur b */
#pragma omp parallel for private(i)
for(i=0;i<dim;i++)
b[i]=i-15;

//CALLGRIND_ZERO_STATS;
//lecture du temps début
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&start);


/*------------------------------------------------------------------------------

* DESCRIPTION : Décomposition LU (stockée dans mat) de la matrice mat

* ENTREES : mat : matrice carrée de doubles

* size : taille de la matrice

* RETOUR : aucun

------------------------------------------------------------------------------*/
for (j=0;j<dim-1;j++)

{

for (i=j+1;i<dim;i++)

{

a[dim*i+j] = a[dim*i+j] / a[dim*j+j]; // Construction de Ek

for (k=j+1;k<dim;k++) // Construction de Ak

{

a[dim*i+k] += -a[dim*i+j] * a[dim*j+k];

}

}

}




/*------------------------------------------------------------------------------

* DESCRIPTION : Résolution de l'équation L*y=b

* ENTREES : LU : matrice carrée de doubles décomposée LU

* b : Vecteur de doubles, second membre de l'équation

* size : taille de la matrice

* RETOUR : Vecteur de doubles solution de l'équation

------------------------------------------------------------------------------*/


for (i=0;i<dim;i++)

{

y[i] = b[i];

for(j=0;j<i;j++)

{

y[i] -= y[j]*a[dim*i+j];

}

}








/*------------------------------------------------------------------------------

* DESCRIPTION : Résolution de l'équation U * x = y

* ENTREES : LU : matrice carrée de doubles décomposée LU

* y : Vecteur de doubles, second membre de l'équation provenant

* de la résolution de L * y = b

* size : taille de la matrice

* RETOUR : Vecteur de doubles solution de l'équation

------------------------------------------------------------------------------*/

for (i=dim-1;i>=0;i--)

{

x[i] = y[i];

for(j=dim-1;j>i;j--)

{

x[i] -= x[j]*a[dim*i+j];

}

x[i] = x[i]/a[dim*i+i];



}






//CALLGRIND_DUMP_STATS;
// lecture du temps d'arrêt
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&end);


// calcul de l'intervalle
nsec =(end.tv_sec * 1e9 + end.tv_nsec) - (start.tv_sec * 1e9 + start.tv_nsec) ;
0