C++ , Minuterie, Millisecondes

Il y a quelques problèmes ici. La première est que vous avez évidemment à commutation de démarrer et d'arrêter le temps lors du passage à diffclock() fonction. Le deuxième problème est l'optimisation. Tout raisonnablement intelligent compilateur avec les optimisations activées serait tout simplement jeter l'ensemble de la boucle de loin car il n'a pas d'effets secondaires. Mais même si vous résoudre les problèmes ci-dessus, le programme serait le plus susceptible d'imprimer 0. Si vous essayez d'imaginer de faire des milliards d'opérations par seconde, jeter sophistiqué de l'exécution des ordres, la prédiction et des tonnes d'autres technologies employées par les Processeurs modernes, même un CPU peut optimiser votre boucle de loin. Mais même si ce n'est pas le cas, vous auriez besoin d'un beaucoup plus que 10K itérations afin de le faire fonctionner plus longtemps. Vous auriez probablement besoin de votre programme à exécuter pendant une seconde ou deux afin d'obtenir clock() reflètent rien.

Mais le problème le plus important est clock() lui-même. Cette fonction n'est pas adapté pour tout le temps des mesures de la performance que ce soit. Ce qu'il fait est vous donne un rapprochement de temps processeur utilisé par le programme. Côté de la vague de la nature de la méthode d'approximation qui peut être utilisé par n'importe quel compte tenu de la mise en œuvre (depuis la norme ne l'exige pas de quelque chose de spécifique), POSIX norme exige également que les CLOCKS_PER_SEC être égale à 1000000 indépendante de la résolution. En d'autres termes, peu importe le degré de précision de l'horloge est, il n'a pas d'importance à la fréquence de votre CPU est en cours d'exécution. Pour le mettre simplement, il est totalement inutile de nombre et donc totalement inutile de fonction. La seule raison pour laquelle il existe encore est probablement pour des raisons historiques. Donc, merci de ne pas l'utiliser.

Pour obtenir ce que vous recherchez, les gens ont utilisé pour lire le Tampon de Temps PROCESSEUR également connu comme "RDTSC" par le nom du PROCESSEUR correspondant instruction utilisé pour le lire. Ces jours-ci, cependant, c'est aussi la plupart du temps inutile car:

1. Les systèmes d'exploitation modernes peuvent facilement migrer le programme à partir d'un PROCESSEUR à l'autre. Vous pouvez imaginer que le temps de lecture de timbre sur un autre CPU après l'exécution d'une seconde sur l'autre qui n'a pas beaucoup de sens. C'est seulement dans les derniers Processeurs Intel, le compteur est synchronisé entre les cœurs. Dans l'ensemble, il est encore possible de le faire, mais beaucoup de précautions supplémentaires doivent être prises (c'est à dire une fois l'installation de l'affinité pour le processus, etc. etc.).
2. De mesure du PROCESSEUR des instructions du programme, souvent, ne donne pas une image précise de la façon dont beaucoup de temps est en fait utilisé. C'est parce que dans la vraie programmes il pourrait y avoir certains appels système où le travail est exécuté par le noyau du système d'exploitation sur le nom du processus. Dans ce cas, que le temps n'est pas inclus.
3. Il pourrait aussi arriver que les OS suspend l'exécution du processus pour une longue période de temps. Et même si il n'a fallu que quelques instructions à exécuter, pour l'utilisateur, il semblait comme une seconde. Donc, une telle mesure de la performance peut être inutile.

Alors que faire?

Quand il s'agit de profilage, un outil comme perf doit être utilisé. Il permet de suivre un certain nombre de CPU horloges, les défauts de cache, de branches, les branches manqué, un certain nombre de fois que le processus a été déplacé d'un PROCESSEUR à l'autre, et ainsi de suite. Il peut être utilisé comme un outil, ou peut être intégré dans votre application (quelque chose comme PAPI).

Et si la question est au sujet de temps réel passé, les gens utilisent une horloge murale. De préférence, une haute précision, c'est pas non plus un sujet de NTP ajustements (monotone). Que montre exactement combien de temps s'est écoulé, peu importe ce qui se passait. À cette fin clock_gettime() peut être utilisé. Il fait partie de SUSv2, POSIX.1-2001 standard. Étant donné que l'utilisation que vous getch() pour garder le terminal ouvert, je suppose que vous êtes à l'aide de Windows. Il y a, malheureusement, vous n'avez pas clock_gettime() et la chose la plus proche serait compteurs de performance API:

BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency);
BOOL QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount);

Pour une solution portable, le meilleur pari est sur std::chrono::high_resolution_clock(). Il a été introduit en C++11, mais est pris en charge par la plupart des industriels de qualité compilateurs (GCC, Clang, MSVC).

Ci-dessous est un exemple de comment l'utiliser. Veuillez noter que depuis que je sais que mon CPU fait 10000 incréments d'un nombre entier de manière plus rapide que un millième de seconde, j'ai changé de microsecondes. J'ai aussi déclaré le compteur comme volatile dans l'espoir que le compilateur n'optimisent pas loin.

#include <ctime>
#include <chrono>
#include <iostream>

int main()
{
    volatile int i = 0; //"volatile" is to ask compiler not to optimize the loop away.
    auto start = std::chrono::steady_clock::now();
    while (i < 10000) {
        ++i;
    }
    auto end = std::chrono::steady_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    std::cout << "It took me " << elapsed.count() << " microseconds." << std::endl;
}

Quand j'ai compiler et l'exécuter, il imprime:

$ g++ -std=c++11 -Wall -o test ./test.cpp && ./test
It took me 23 microseconds.

Espère que cela aide. Bonne Chance!

OriginalL'auteur

Tout d'abord, vous devez soustraire la fin - début pas vice-versa.

La Documentation dit que si la valeur n'est pas disponible horloge() renvoie -1, avez-vous vérifier?
Ce niveau d'optimisation utilisez-vous lors de la compilation de votre programme? Si l'optimisation est activée compilateur peut éliminer efficacement votre boucle entièrement.

OriginalL'auteur Slava