rusage, utilisation CPU précise à la microseconde ?

Version imprimable

Bonjour, dans un code existant que je dois maintenir un calcul est fait pour déterminer l'utilisation CPU de certaines parties du programme qui sont très brèves (en dizaines/centaines de microsecondes).
Le code utilise la fonction getrusage :
Code:

1 2 3 4 5 6 7 struct rusage usage; if (getrusage(RUSAGE_THREAD, &usage) == 0) { // calculate time in microseconds currentCpuUsage = usage.ru_utime.tv_sec*1000000 + usage.ru_utime.tv_usec + usage.ru_stime.tv_sec*1000000 + usage.ru_stime.tv_usec; }
Classique, le code enregistre la valeur courante au début de la période que l'on veut mesurer puis fait la différence avec la valeur courante à la fin de cette période.

Le problème, les deux valeurs sont la plupart du temps égales (différence nulle donc) et parfois avec une différence de 4000 (4 ms donc). Est-ce que c'est une limitation de la précision ? Est-ce qu'il y a quelque chose à faire dans le code ou bien un autre moyen de récupérer l'utilisation CPU avec une meilleure précision ?

Merci d'avance !

25/02/2014, 20h44
Neckara

Bonjour,

En C++11, tu as std::chrono qui te permet de choisir l'horloge que tu veux utiliser et parmi les trois possibles, il me semble qu'il y en a une très précise, peu-être devrais-tu regarder de ce côté là?
26/02/2014, 09h56
ymoreau

On n'utilise pas le C++11 sur le projet. Cependant si l'horloge existe dans le système (Linux Debian) je suppose qu'on peut y accéder directement avec une API C, ma question est surtout est-ce qu'une telle horloge existe ? Surtout que le code actuel est sensé récupérer une précision en microsecondes mais on n'observe jamais de pas de valeur inférieur à 4 millisecondes.
26/02/2014, 10h02
LittleWhite

Bonjour,

Avez-vous essayé gettimeofday ?
Je ne connaissais pas getrusage. Après, en effet, la fonction que je propose ne donne qu'un temps et pas une utilisation. Pour une utilisation, j'irai voir du côté des compteurs CPU (nombre d'instructions écoulées).
26/02/2014, 10h11
Neckara
Citation:

Envoyé par ymoreau

On n'utilise pas le C++11 sur le projet. Cependant si l'horloge existe dans le système (Linux Debian) je suppose qu'on peut y accéder directement avec une API C, ma question est surtout est-ce qu'une telle horloge existe ?

Le fait que tu n'utilises pas le C++11 ne t'empêche pas de tester.

On a std::chrono::high_resolution_clock, rien ne t'empêche de tester/regarder sa résolution même si dans ton projet vous n'utilisez pas le C++11 pour voir si tu trouves une résolution supérieur ainsi :
- si tu trouves un résolution supérieur, tu sais qu'il existe une telle horloge et tu peux alors rechercher plus en détail comment faire avec l'API C.
- sinon, tu peux penser qu'il y a peu de chance qu'il existe une telle horloge si la high_resolution_clock n'a pas une plus grande résolution.
Je viens de voir que boost propose la même chose et que high_resolution_clock peut avoir des valeurs avec des précisions en nanosecondes.
Après, c'est la durée totale et pas la durée d'occupation du cpu. Mais pour des valeurs aussi petites, je pense que c'est significativement égal.
26/02/2014, 11h14
ymoreau

Merci pour vos réponses.
En fait je ne l'ai pas précisé mais le temps total écoulé est également récupéré, et celui ci est bien précis à la microseconde. C'est vraiment sur cette info d'utilisation CPU que les valeurs ont des paliers de 4000 microsecondes, ce qui me fait penser que c'est une limitation du système mais peut être qu'il existe un autre moyen.
26/02/2014, 15h18
gangsoleil

Bonjour,

Est-ce que tu es sur un systeme temps-reel ?

Une precision de 4ms, je trouve ca deja pas mal : sur de vieux serveurs, je ne pouvais pas descendre en dessous de 20ms :)

Apres, que ce soit Boost ou n'importe quelle autre bibliothèque, je ne pense pas que tu obtiennes des mesures plus precises que ca, mais c'est vrai que ca peut valoir le coup de tester -- si jamais ton code est compatible C++, ca ne devrait pas etre complexe de faire un SSCCE.

Et si tu as besoin d'une telle precision, le code que tu as montre est probablement trop consomateur : il faut utiliser deux variables, usage_before et usage_after, et ne faire les calcus qu'apres l'appel de ta fonction -- fonction inline bien evidemment, probablement en assembleur.

On utilise Debian 6.0.7 (sans modif particulière), à ma connaissance ça n'est pas un système temps réel. Le matériel non plus, on a des simples pc standards.

J'ai un fait un code indépendant du projet et je retrouve bien ces paliers de 4ms, j'imagine qu'il n'y a rien à faire tant qu'on est sur cet OS et ce matériel. Merci pour vos réponses !

Code:

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
#include <sys/time.h>
#include <sys/resource.h>
#include <iostream>
 
using namespace std;
 
int main()
{
    struct rusage usage_before, usage_after;
 
    cout << "--- CPU processing" << endl;
    for (int i=0; i < 100; ++i)
    {
        getrusage(RUSAGE_THREAD, &usage_before);
 
        // Some dumb CPU processing
        char a;
        for (int k=0; k < (i * 100000); ++k)
        {
            ++a;
        }
 
        getrusage(RUSAGE_THREAD, &usage_after);
 
        cout << i << " : " << usage_after.ru_utime.tv_sec - usage_before.ru_utime.tv_sec << "s "
             << usage_after.ru_utime.tv_usec - usage_before.ru_utime.tv_usec << "us " << endl;
    }
 
    return 0;
}