Temps d'exécution
biba
-
biba -
biba -
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.
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
si ton temps devient négatif, es-tu sûr d'utiliser le bon type de variable, int au lieu de long ?, par ex.
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
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
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,
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,
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,
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,
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) ;
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) ;
il s'agit d'une matrice allouée dynamiquement d'entiers ou de float ou de double.