Discussion :

[darkantoine]

Bonjour,

J'utilise la libraire GMP pour faire des calculs avec des grands nombres.
J'essaie de calculer le temps nécessaire pour évaluer le carré d'un nombre.
Je précise que je compile et exécute sous Windows 7 32 bits et j'ai un Quad Core.

Mais lorsque j'affiche la durée, ça affiche n'importe quoi ( en fait ça affiche pratiquement tout le temps la même durée alors que clairement les temps sont différents)
J'ai essayé plusieurs méthodes pour afficher la durée et j'ai trouvé un code sur le net qui semblait plus pertinent qu'un clock() ( mais ça ne change rien finalement)

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
 
#define Ms 1000
#define Us 1000000
#define Ns 1000000000
 
class PerfChrono
{
    __int64 freq, t0; //la frequence de l'horloge et le temps initial
 
public:
    PerfChrono() //Le constructeur qui va récupérer la fréquence de l'horloge
    {
        QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
 
    }
 
    void Start()
    {
        QueryPerformanceCounter((LARGE_INTEGER*)&t0);
 
    }
 
    DWORD GetDiffMs()
    {
        __int64 t1; 
        QueryPerformanceCounter((LARGE_INTEGER*)&t1); 
        return (DWORD)(((t1 - t0) * 1000) / freq); 
    }
 
 
    DWORD GetDiff(UINT unit)
    {
        __int64 t1;
        QueryPerformanceCounter((LARGE_INTEGER*)&t1);
        return (DWORD)(((t1 - t0) * unit) / freq);
    }
 
    DWORD GetFreq()
    {
        return (DWORD)freq;
    }
};

et mon code ( simplifié)

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
 
unsigned int nb_rounds = 100000000;
 
for(unsigned int i=0; i<10; i++)
{
        bigint=bigint*bigint*bigint*bigint;
 
 
     Chrono.Start();
 
 
   // ICI COMMENCE LA BOUCLE A EVALUER
 
        for(unsigned int j=0; j<nb_rounds; j++)
        {
         bigint*bigint;  
        }
 
        cout << "tour: "<<i<< endl;
        cout << Chrono.GetDiffMs() << endl;
}

Quand j'exécute j'obtient :

tour: 0
674
tour: 1
675
tour: 2
679
tour: 3
674
...

Une idée du pourquoi du comment?

Qu'est ce que je peux utiliser d'autre?

Merci d'avance

[Sylvain Togni]

A mon avis ce n'est pas la façon de mesurer le temps qui ne va pas, mais le code en lui même.

Combien vaut bigint au départ ?

[darkantoine]

bigint vaut une valeur aleatoire sur 100 bits

mais le problème avec le temps est bien visible

car le 1ere test dure moins d'une seconde et le dernier dure 3,4 secondes.

Mais la durée affichée est pratiquement la même à chaque fois :S

[screetch]

a mon avis le résultat est correct, c'est plutot la console qui lagge. Qu'est ce qui te fais penser que le temps entre chaque tour devrait etre different puisque tu fais la meme chose?
peut etre la machine a t'elle du mal a executer du coup la console traine un peu derriere?

[darkantoine]

Non je fais pas la même chose

Avant chaque boucle je fais

Code :

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

1
2
 
 bigint=bigint*bigint*bigint*bigint;

Ce qui fait que la taille de bigint est multiplié par 4

normalement l'operation biging*bigint prend donc 4log(4) fois plus de temps... (avec un algo type karatsuba ou Tom-cook)

Ah oui bigint est un type mpz_class de GMP ( c'est peut etre bien de préciser )


Voici le code complet du main pour plus de clarté :

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
74
75
 
#include <cstdlib>
#include <iostream>
#include <gmpxx.h>
#include <time.h>
 
#include "chrono.h"
 
 
using namespace std;
 
#define MAXSIZE 100 
 
 
unsigned int rand_number;
 
unsigned int random(unsigned int n);
 
int main(int argc, char **argv)
{
srand(time(NULL));
rand_number= rand();
 
 
char nombre[MAXSIZE];
for(int i=0; i<MAXSIZE; i++)
{
        nombre[i]= '0' + ((char)random(10));
}
mpz_class bigint(nombre, 10);
cout << bigint << endl;
 
PerfChrono Chrono;
 
 
 
 
 
//float temps_cpu;     /* Temps total en secondes */ 
 
unsigned int nb_rounds = 100000000;
 
for(unsigned int i=0; i<10; i++)
{
        bigint=bigint*bigint*bigint*bigint;
 
 
     Chrono.Start();
 
 
 
 
        for(unsigned int j=0; j<nb_rounds; j++)
        {
         bigint*bigint;  
        }
 
        cout << "tour: "<<i<< endl;
        cout << Chrono.GetDiffMs() << endl;
}
 
 
 
 
 system("PAUSE");
	return 0;
 
}
 
 
unsigned int random(unsigned int n)
{
    rand_number = ( rand_number * rand_number ) % ( (1 << 30 ) -1);
    return (rand_number % n);
}

[darkantoine]

J'ai finalement réessayé avec clock() et j'obtiens maintenant des résultats cohérents...

Je ne sais pas trop ce qui s'est passé...

Merci pour vos réponses en tout cas