2017-10-06 9 views
0

Je suis en train d'écrire un programme de test en profondeur pour une structure de données que j'ai dû écrire pour une classe. J'essaye de chronométrer combien de temps il prend des fonctions pour les exécuter et les stocker dans un tableau pour l'impression postérieure. Pour vérifier que cela fonctionnait, j'ai décidé de l'imprimer immédiatement, et j'ai découvert que ça ne fonctionnait pas.Fonctions de synchronisation: Retour double 0 MS

Voici le code où j'obtiens les heures et les stocke dans un tableau qui est dans une structure.

void test1(ArrayLinkedBag<ItemType> &bag,TestAnalytics &analytics){ 
    clock_t totalStart; 
    clock_t incrementalStart; 
    clock_t stop; //Both timers stop at the same time; 
    // Start TEST 1 
    totalStart = clock(); 
    bag.debugPrint(); 

    cout << "Bag Should Be Empty, Checking..." << endl; 
    incrementalStart = clock(); 
    checkEmpty<ItemType>(bag); 
    stop = clock(); 
    analytics.test1Times[0] = analytics.addTimes(incrementalStart,stop); 
    analytics.test1Times[1] = analytics.addTimes(totalStart,stop); 
    cout << analytics.test1Times[0] << setprecision(5) << "ms" << endl; 
    std::cout << "Time: "<< setprecision(5) << (stop - totalStart)/(double)(CLOCKS_PER_SEC/1000) << " ms" << std::endl; 
    cout << "===========================================" << endl; //So I can find the line easier 

} 

Voici le code où je fais le calcul que je mettais dans le tableau, cette fonction est situé dans une struct TestAnalytics

double addTimes(double start, double stop){ 
    return (stop - start)/ (double)(CLOCKS_PER_SEC/1000); 
    } 

Voici un extrait de la sortie que je reçois :

Current Head: -1 
Current Size: 0 
Cell: 1, Index: 0, Item: 6317568, Next Index: -2 
Cell: 2, Index: 1, Item: 4098, Next Index: -2 
Cell: 3, Index: 2, Item: 6317544, Next Index: -2 
Cell: 4, Index: 3, Item: -683175280, Next Index: -2 
Cell: 5, Index: 4, Item: 4201274, Next Index: -2 
Cell: 6, Index: 5, Item: 6317536, Next Index: -2 
Bag Should Be Empty, Checking... 
The Bag Is Empty 
0ms 
Time: 0 ms 
=========================================== 

J'essaye de calculer l'heure selon un article différent sur ce site. J'utilise le compilateur clang sur un système UNIX. Est-il possible que le nombre est encore trop petit pour montrer au-dessus de 0?

+0

'CLOCKS_PER_SEC/1000' pourrait être une division entière; Je ne sais pas si cela est lié à votre problème –

+0

@ M.M Je suis en train de couler cela à un double cependant. Je viens de remarquer que mon arrêt et totalStart impression à la fois 0. –

+0

à '1000.0', il n'y a pas de point de coulée à un double après que vous avez déjà fait division entière –

Répondre

1

Sauf si vous êtes coincé avec un vieux compilateur/bibliothèque (pré-C++ 11), j'utiliser les fonctions de l'en-tête <chrono>:

template <class ItemType> 
void test1(ArrayLinkedBag<ItemType> &bag){ 
    using namespace std::chrono; 

    auto start = high_resolution_clock::now(); 
    bag.debugPrint(); 
    auto first = high_resolution_clock::now(); 
    checkEmpty(bag); 
    auto stop = high_resolution_clock::now(); 

    std::cout << " first time: " << duration_cast<microseconds>(first - start).count() << " us\n"; 
    std::cout << "second time: " << duration_cast<microseconds>(stop - start).count() << " us\n"; 
} 

Certaines parties sont un peu bavard (pour le mettre gentiment) mais ça marche encore raisonnablement bien. duration_cast prend en charge les types de différence jusqu'à (au moins) nanoseconds, ce qui est généralement suffisant pour chronométrer même des morceaux de code relativement petits/rapides (bien qu'il ne soit pas garanti qu'il utilise une minuterie avec une précision de l'ordre de la nanoseconde).

+0

Merci, je vais travailler En essayant ça demain quand je reviendrai, je vous le ferai savoir. –

1

En plus de Jerry's good answer (que j'ai upvoted), je voulais ajouter juste un peu plus d'informations qui pourraient être utiles.

Pour la synchronisation je recommande steady_clock sur high_resolution_clock parce que steady_clock est garanti de ne pas être ajusté (en particulier en arrière) pendant votre synchronisation. Maintenant, sur Visual Studio et clang, cela ne peut pas arriver parce que high_resolution_clock et steady_clock sont exactement le même type. Cependant, si vous utilisez gcc, high_resolution_clock est du même type que system_clock, qui peut être ajusté à tout moment (disons par une correction NTP). Mais si vous utilisez steady_clock, alors sur chaque plate-forme vous avez un chronomètre de type chronomètre: Pas bon pour vous dire l'heure du jour, mais pas sujet à être corrigé à un moment inopportun.

En outre, si vous utilisez my free, open-source, header-only <chrono> extension library, il peut diffuser des durées d'une manière beaucoup plus amicale, sans avoir à utiliser duration_cast ni .count(). Il imprimera les unités de durée juste avec la valeur. Enfin, si vous appelez le steady_clock::now() plusieurs fois de suite (sans rien entre les deux), et imprimez cette différence, vous pouvez avoir une idée de la précision avec laquelle votre implémentation est capable de chronométrer les choses. Peut-il chronométrer quelque chose d'aussi court que les femtosecondes? Probablement pas. Est-ce aussi grossier que millisecondes? Nous espérons que non.

Mettre tout cela ensemble, le programme suivant a été compilé comme ceci:

clang++ test.cpp -std=c++14 -O3 -I../date/include 

Le programme:

#include "date/date.h" 
#include <iostream> 

int 
main() 
{ 
    using namespace std::chrono; 
    using date::operator<<; 
    for (int i = 0; i < 100; ++i) 
    { 
     auto t0 = steady_clock::now(); 
     auto t1 = steady_clock::now(); 
     auto t2 = steady_clock::now(); 
     auto t3 = steady_clock::now(); 
     auto t4 = steady_clock::now(); 
     auto t5 = steady_clock::now(); 
     auto t6 = steady_clock::now(); 
     std::cout << t1-t0 << '\n'; 
     std::cout << t2-t1 << '\n'; 
     std::cout << t3-t2 << '\n'; 
     std::cout << t4-t3 << '\n'; 
     std::cout << t5-t4 << '\n'; 
     std::cout << t6-t5 << '\n'; 
    } 
} 

Et sortie pour moi macOS:

150ns 
80ns 
69ns 
53ns 
63ns 
64ns 
88ns 
54ns 
66ns 
66ns 
59ns 
56ns 
59ns 
69ns 
76ns 
74ns 
73ns 
73ns 
64ns 
60ns 
58ns 
...