Temps de traitement précis (ou supérieur) en quelques secondes sous Linux

Question

J'ai besoin d'un moyen très précis de chronométrer certaines parties de mon programme. Je pourrais utiliser l'horloge haute résolution normale pour cela, mais cela va retourner l'heure de wallclock, ce qui n'est pas ce dont j'ai besoin: j'ai besoin du temps passé à exécuter uniquement mon processus.

Je me souviens très bien d'avoir vu un correctif de noyau Linux qui me permettrait de chronométrer mes processus avec une précision de l'ordre de la nanoseconde, sauf que j'ai oublié de le marquer dans un signet et j'ai également oublié le nom du correctif: (.

Je me souviens comment cela fonctionne bien:

À chaque changement de contexte, il lit la valeur d'une horloge haute résolution et ajoute le delta des deux dernières valeurs à la durée du processus en cours. Ceci produit une vue précise haute résolution du temps de traitement réel du processus.

Le temps de traitement normal est conservé en utilisant l'horloge normale, ce qui, je crois, est précise à la milliseconde près (1000Hz), ce qui est beaucoup trop grand pour mes besoins.

Quelqu'un sait-il de quel correctif de noyau je parle? Je me souviens aussi que c’était comme un mot avec une lettre avant ou après, quelque chose comme «minuteur» ou autre chose, mais je ne me souviens pas exactement.

(D'autres suggestions sont également les bienvenues)

Le planificateur tout à fait juste suggéré par Marko n’est pas ce que je cherchais, mais il semble prometteur. Le problème que j'ai avec elle est que les appels que je peux utiliser pour obtenir le temps de traitement ne renvoient toujours pas de valeurs suffisamment granulaires.

• times () renvoie les valeurs 21, 22, en millisecondes.
• clock () renvoie les valeurs 21000, 22000, même granularité.
• getrusage () renvoie des valeurs telles que 210002, 22001 (et ainsi de suite), elles semblent avoir une précision un peu meilleure, mais les valeurs ont sensiblement la même apparence.

Alors maintenant, le problème que je rencontre est probablement que le noyau dispose des informations nécessaires, je ne connais pas l'appel système qui les renverra.

Answer 1

Si vous recherchez ce niveau de résolution temporelle, vous essayez probablement de faire de la micro-optimisation. Si tel est le cas, consultez PAPI . Non seulement il fournit des informations de minutage d'horloge murale et virtuelle (processus uniquement), mais il donne également accès aux compteurs d'événements du processeur, ce qui peut être indispensable lorsque vous essayez d'améliorer les performances.

http://icl.cs.utk.edu/papi/

Answer 2

Voir cette question pour plus d'informations. .

Quelque chose que j'ai utilisé pour de telles choses est gettimeofday (). Il fournit une structure avec des secondes et des microsecondes. Appelez-le avant le code, et encore après. Ensuite, il vous suffit de soustraire les deux structures à l’aide de timersub pour obtenir le temps qu’il a fallu en secondes au champ tv_usec.

Answer 3

Si vous avez besoin de très petites unités de temps pour (je suppose) tester la vitesse de votre logiciel, je vous recommande d'exécuter simplement les parties que vous souhaitez programmer en boucle des millions de fois, prenez le temps avant et après la boucle et calculer la moyenne. Un effet secondaire intéressant de cette opération (à part le fait de ne pas avoir besoin de savoir comment utiliser les nanosecondes) est que vous obtiendrez des résultats plus cohérents, car la surcharge aléatoire causée par le gestionnaire de système os sera moyennée.

Bien sûr, à moins que votre programme n'ait pas besoin de pouvoir s'exécuter des millions de fois en une seconde, il est probablement assez rapide si vous ne pouvez pas mesurer une milliseconde de temps d'exécution.

Answer 4

Je pense que CFC ( un planificateur tout à fait juste ) est ce que vous recherchez.

Answer 5

Vous pouvez utiliser le programmateur d'événements haute précision ( HPET ) si vous avez un problème assez récent. Noyau 2.6. Consultez Documentation / hpet.txt pour savoir comment l'utiliser. Cette solution dépend toutefois de la plate-forme et je pense qu’elle n’est disponible que sur les nouveaux systèmes x86. HPET a au moins une minuterie de 10 MHz, il devrait donc s'adapter facilement à vos besoins.

Je pense que plusieurs implémentations PowerPC de Freescale prennent également en charge un compteur d’instructions de cycle exact. Je l'ai utilisé il y a plusieurs années pour établir un profil de code hautement optimisé, mais je ne me souviens plus de son nom. Je pense que Freescale a un correctif de noyau à appliquer pour pouvoir y accéder depuis l’espace utilisateur.

Answer 6

http://allmybrain.com/2008/ 06/10 / timing-cc-code-on-linux /

pourrait vous être utile (directement si vous le faites en C / C ++, mais j'espère que cela vous donnera des indications, même si vous ne l'êtes pas) ... Il prétend fournir une précision de l'ordre de la microseconde, qui dépasse critère. :)

Answer 7

Je pense avoir trouvé le correctif de noyau que je cherchais. Le poster ici pour ne pas oublier le lien:

http://user.it.uu.se/~mikpe/ linux / perfctr / http://sourceforge.net/projects/perfctr/

Éditer: cela fonctionne à mes fins, bien que cela ne soit pas très convivial.

Answer 8

essayez le compteur d'horodatage du processeur. Wikipedia semble suggérer d'utiliser clock_gettime ().