Discussion :

[grunk]

Bonjour à tous,

J'ai un code windows qui doit être porté sous linux et macos.

Dans ce code est utilisé une structure SYSTEMTIME comme suit :

Code :

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

1
2
SYSTEMTIME st;
GetSystemTime(&st);

Je n'ai pas besoin de faire de calcul sur la date récupérée juste être capable de ressortir les différentes infos. La résolution à la millisecond est impérative.
Je recherche donc un équivalent à tm mais avec les millisecondes en plus.

La structure étant instancié très souvent ( à minima tte les 40ms) j'aimerais rester sur quelque chose très simple et ne pas traîner un ensemble de classe comme avec boost::posix_time::ptime

J'ai bien pensé à redéfinir la même structure quand elle n'existe pas , mais se pose alors la question du remplissage de la structure.

Des idées ?

Merci

[foetus]

Et un truc comme cela : How to get the elapsed real time

Mais après quelques tests sous Windows:
1) #if defined(NTDDI_WIN8) && NTDDI_VERSION >= NTDDI_WIN8 ne fonctionne pas sous Visual 2013
2) GetSystemTimeAsFileTime est souvent la plus rapide, mais devrait donner un temps imprécis. Moi je n'ai jamais eu de problème

[Médinoc]

La précision de telles fonctions sous Windows est la même durée qu'un quantum de thread: 1/64e de seconde, c'est-à-dire 15.625ms.
À ma connaissance, GetSystemTime() fait juste GetSystemTimeAsFileTime() puis FileTimeToSystemTime().

Sous *n*x, j'ai du mal à trouver une fonction de temps qui soit plus précise qu'une seconde. Possiblement ftime(), puis il doit y avoir des fonctions de conversion...

[Ehonn]

En C++11 avec chrono :

Code :

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

1
2
auto duration = std::chrono::steady_clock::now().time_since_epoch(); // Il existe différentes clocks : std::system_clock, std::high_resolution_clock
auto t = std::chrono::duration<T, std::milli>(duration).count(); // Remplacer T par le type voulu

[Ehonn]

Sous *n*x, j'ai du mal à trouver une fonction de temps qui soit plus précise qu'une seconde. Possiblement ftime(), puis il doit y avoir des fonctions de conversion...

gettimeofday

[koala01]

Salut,

As-tu regardé du coté de l'en-tête <chrono> et plus particulièrement du coté de std::time_point

Car, le fait est que, même si c'est instancié très souvent, tu ne vas sans doute pas garder ces instances très souvent, et que la précision à la milli seconde ne pose absolument aucun problème (cela dépend d'ailleurs du système d'exploitation, mais une précision de l'ordre de la µs est généralement possible).

Par contre, il serais dommage de t'emm... der à recréer quelque chose alors qu'une fonctionnalité équivalente est fournie par la bibliothèque standard! Et toutes les fonctions qui te permettent d'effectuer les calculs intéressants sont fournies en prime

[grunk]

chrono semble être une solution envisageable.

Merci pour vos réponses

[dalfab]

Bonjour,

Une des fonctions à la fois rapide et précise est RDTSC, cette instruction assembleur existe sur presque tous les processeurs (Intel, Amd, ARM, PowerPC), ne prends qu'1 ou 2 cycles en exécution et mesure des cycles d'horloge (donc précision en ns).
Seul inconvénient sa portabilité.
Exemple en QNX :

Code :

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

1
2
3
4
5
uint64_t cps = SYSPAGE_ENTRY(qtime)->cycles_per_sec; // la fréquence du processeur
uint64_t cycle1=ClockCycles();  // ou __rdtsc();
// traitement à mesurer
uint64_t cycle2=ClockCycles();  // ou __rdtsc();
cout << "temps écoulé en ns" << 1000000000uLL*(cycle2-cycle1)/cps;

[Ehonn]

Il faut également faire attention à la conversion des cycles en temps car la fréquence du processeur peut changer durant l'exécution (économie d'énergie, mode turbo). Une solution est de la fixer avant de lancer le programme.