Discussion :

[ymoreau]

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 C++ :

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

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 !

[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à?

[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.

[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).

[Neckara]

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.

[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.

[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.

[ymoreau]

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 C++ :

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
#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;
}