web-dev-qa-db-fra.com

Comment utiliser clock () en C ++

Comment appeler clock() dans C++?

Par exemple, je veux tester le temps nécessaire à une recherche linéaire pour trouver un élément donné dans un tableau.

c++benchmarkingclock
120
dato datuashvili
#include <iostream>
#include <cstdio>
#include <ctime>

int main() {
    std::clock_t start;
    double duration;

    start = std::clock();

    /* Your algorithm here */

    duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;

    std::cout<<"printf: "<< duration <<'\n';
}
191
Dolph

Une solution alternative, portable et plus précise, disponible depuis C++ 11, consiste à utiliser std::chrono.

Voici un exemple:

#include <iostream>
#include <chrono>
typedef std::chrono::high_resolution_clock Clock;

int main()
{
    auto t1 = Clock::now();
    auto t2 = Clock::now();
    std::cout << "Delta t2-t1: " 
              << std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count()
              << " nanoseconds" << std::endl;
}

Courir ceci sur ideone.com m'a donné:

Delta t2-t1: 282 nanoseconds
62
Martin G

clock() renvoie le nombre de coups d'horloge depuis le début du programme. Il existe une constante associée, CLOCKS_PER_SEC, qui indique le nombre de ticks d'horloge produits en une seconde. Ainsi, vous pouvez tester n'importe quelle opération comme celle-ci:

clock_t startTime = clock();
doSomeOperation();
clock_t endTime = clock();
clock_t clockTicksTaken = endTime - startTime;
double timeInSeconds = clockTicksTaken / (double) CLOCKS_PER_SEC;
29
Shirik

Sous Windows au moins, le mécanisme de mesure pratiquement précis seulement est QueryPerformanceCounter (QPC). std :: chrono est implémenté en l'utilisant (depuis VS2015, si vous l'utilisez), mais il est pas aussi précis que l'utilisation directe de QueryPerformanceCounter. En particulier, il est prétendument inexact de faire état d'une granularité d'une nanoseconde. Ainsi, si vous mesurez quelque chose qui prend très peu de temps (et que votre cas pourrait bien en être un), vous devriez alors utiliser QPC, ou l’équivalent pour votre système d’exploitation. Je me suis heurté à cela lors de la mesure des latences du cache, et j’ai noté quelques notes que vous pourriez trouver utiles, ici; https://github.com/jarlostensen/notesandcomments/blob/master/stdchronovsqcp.md

4
SonarJetLens
#include <iostream>
#include <ctime>
#include <cstdlib> //_sleep()  --- just a function that waits a certain amount of milliseconds

using namespace std;

int main()
{

    clock_t cl;     //initializing a clock type

    cl = clock();   //starting time of clock

    _sleep(5167);   //insert code here

    cl = clock() - cl;  //end point of clock

    _sleep(1000);   //testing to see if it actually stops at the end point

    cout << cl/(double)CLOCKS_PER_SEC << endl;  //prints the determined ticks per second (seconds passed)


    return 0;
}

//outputs "5.17"
1
Garrett