Mesurer le temps en Linux - getrusage vs clock_gettime vs horloge gettimeofday vs ?

Question

Parmi les quatre fonctions de temporisation, getrusage, clock_gettime, clock, et gettimeofday je veux bien comprendre comment ils sont mis en œuvre et quelles sont leurs valeurs de retour afin de savoir dans quelle situation je suis obligé de l'utiliser.

Nous avons besoin d'abord de classer les fonctions de renvoi de l'horloge de mur valeurs comparer aux fonctions de renvoi de processus ou threads valeurs. gettimeofday renvoie l'horloge murale de la valeur, en clock_gettime renvoie l'horloge murale de la valeur ou de processus ou threads valeurs en fonction du Clock paramètre passé à elle. getrusage et clock processus de retour des valeurs.

Ensuite, la deuxième question concerne la mise en œuvre de ces fonctions et, en conséquence, leur exactitude. Qui de logiciel ou de matériel mécanisme de ces fonctions.

Il semble qu' getrusage utilise seulement le noyau de la tique (généralement de 1 ms de temps), et en conséquence ne peuvent pas être plus précis que le ms. Est-il juste? Puis l' getimeofday fonction semble être d'utiliser le plus précis des matériels sous-jacents disponibles. Comme une conséquence de sa précision est généralement la microseconde (ne peut pas être plus en raison de l'API) sur un matériel récent. Qu'en clock, la page de man de parler de "rapprochement", ça veut dire quoi? Qu'en clock_gettime, l'API est dans l'ordre de la nanoseconde, ça signifie qu'il est capable d'être très précis si le matériel le permet? Ce sujet de monotonie?

Existe-il d'autres fonctions?

Answer 1

Le problème est qu'il existe plusieurs fonctions de temps disponible en C et C++, et certaines d'entre elles varient dans le comportement entre les implémentations. Il y a aussi beaucoup de demi-réponses flottant autour. La compilation d'une liste des fonctions de l'horloge avec leurs propriétés permettrait de répondre à la question correctement. Pour les mises en chantier demandons à ce que les propriétés concernées sont que nous recherchons. En regardant ton post, je vous suggère:

• Ce temps est mesuré par l'horloge? (réel, l'utilisateur, le système, ou, espérons-le pas, l'horloge de mur?)
• Quelle est la précision de l'horloge? (s, ms, µs, ou plus rapide?)
• Après combien de temps l'horloge enrouler autour? Ou est-il un mécanisme pour éviter cela?
• L'horloge est monotone, ou que ça va changer avec les changements dans le temps système (via NTP, fuseau horaire, heure d'été, par l'utilisateur, etc.)?
• Comment faire ci-dessus varient entre les implémentations?
• Est la fonction spécifique obsolète, non standard, etc.?

Avant de commencer la liste, je tiens à souligner que l'horloge murale est rarement le bon moment pour utiliser, alors qu'il change avec les changements de fuseau horaire, heure d'été, des changements, ou si le mur de l'horloge est synchronisée par le NTP. Aucune de ces choses sont bonnes si vous utilisez le temps de planifier des événements, ou à la performance de référence. Il n'y a vraiment que du bon pour ce que son nom indique, une horloge sur le mur (ou de bureau).

Voici ce que j'ai trouvé à ce jour pour les horloges dans Linux et OS X:

• time() retourne l'horloge murale de l'OS, avec précision, dans les secondes.
• clock() semble renvoyer à la somme de l'utilisateur et le système de temps. À une époque, c'était censé être le temps de calcul dans les cycles, mais les normes modernes exigent CLOCKS_PER_SEC à 1000000, en donnant un maximum de précision possible à 1 µs. La précision sur mon système est en effet de 1 µs. Cette horloge s'enroule autour de une fois il est en tête (ce qui arrive généralement après ~2^32 tiques, ce qui n'est pas très long pour un pas de 1 MHz horloge).
• clock_gettime(CLOCK_MONOTONIC, ...) offre une résolution d'une, est monotone. Je crois que les "secondes" et "nanosecondes' sont stockés séparément, chacun dans des compteurs 32 bits. Ainsi, toute wrap-around aurait lieu après de nombreuses douzaine d'années de la durée de fonctionnement. Cela ressemble à une très bonne horloge, mais malheureusement, il n'est pas encore disponible sur OS X.
• getrusage() s'est avéré être le meilleur choix pour ma situation. Il signale à l'utilisateur et du système de fois séparément et n'est pas autour. La précision sur mon système est de 1 µs, mais je l'ai aussi testé sur un système Linux (Red Hat 4.1.2-48 avec GCC 4.1.2) et il y a la précision était de 1 ms seulement.
• gettimeofday() retourne l'horloge murale avec (en théorie) µs précision. Sur mon système, cette horloge ne semblent avoir µs précision, mais ce n'est pas garanti, parce que "la résolution de l'horloge système est dépendant du matériel".
• mach_absolute_time() est une option pour une très haute résolution (ns) moment sur OS X. Sur mon système, c'est donner des ns de résolution. En principe, cette horloge s'enroule autour, cependant il est de stocker des ns aide d'une version 64 bits entier non signé, de sorte que l'emballage autour ne devrait pas être un problème dans la pratique. La portabilité est discutable.
• J'ai écrit une fonction hybride basé sur cet extrait de code qui utilise clock_gettime lors de la compilation sous Linux, ou un Mach de la minuterie, lors de la compilation sur OS X, afin d'obtenir des ns de précision sur Linux et OS X.

Tous les ci-dessus existent dans Linux et OS X, sauf indication contraire. "Mon système" dans le ci-dessus est un Apple exécutant OS X 10.8.3 avec GCC 4.7.2 de MacPorts.

Enfin, voici une liste de références que j'ai trouvé utile en plus les liens ci-dessus:
http://blog.habets.pp.se/2010/09/gettimeofday-should-never-be-used-to-measure-time
Comment mesurer la RÉELLE temps d'exécution d'un programme en C sous Linux?
http://digitalsandwich.com/archives/27-benchmarking-misconceptions-microtime-vs-getrusage.html
http://www.unix.com/hp-ux/38937-getrusage.html