it-swarm.com.de

Verstrichene Zeit einfach messen

Ich versuche time () zu verwenden, um verschiedene Punkte meines Programms zu messen.

Was ich nicht verstehe ist, warum die Werte im Vorher und Nachher gleich sind? Ich verstehe, dass dies nicht der beste Weg ist, mein Programm zu profilieren. Ich möchte nur sehen, wie lange etwas dauert.

printf("**MyProgram::before time= %ld\n", time(NULL));

doSomthing();
doSomthingLong();

printf("**MyProgram::after time= %ld\n", time(NULL));

Ich habe versucht:

struct timeval diff, startTV, endTV;

gettimeofday(&startTV, NULL); 

doSomething();
doSomethingLong();

gettimeofday(&endTV, NULL); 

timersub(&endTV, &startTV, &diff);

printf("**time taken = %ld %ld\n", diff.tv_sec, diff.tv_usec);

Wie lese ich ein Ergebnis von **time taken = 0 26339? Bedeutet das 26.339 Nanosekunden = 26,3 ms?

Was ist mit **time taken = 4 45025, bedeutet das 4 Sekunden und 25 ms?

264
hap497
_#include <ctime>

void f() {
  using namespace std;
  clock_t begin = clock();

  code_to_time();

  clock_t end = clock();
  double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
}
_

Die Funktion time() ist nur auf eine Sekunde genau, aber es gibt CLOCKS_PER_SEC "Uhren" innerhalb einer Sekunde. Dies ist eine einfache, tragbare Messung, auch wenn sie stark vereinfacht ist.

260
Roger Pate

Sie können den Zeitmessmechanismus abstrahieren und die Laufzeit jedes Aufrufbaren mit minimaler Zusatzcode messen lassen, indem Sie einfach über eine Timer-Struktur aufgerufen werden. Außerdem können Sie zur Kompilierungszeit den Timing-Typ parametrieren (Millisekunden, Nanosekunden usw.).

Dank der Überprüfung durch Loki Astari und dem Vorschlag, verschiedene Vorlagen zu verwenden.Dies ist der Grund, warum der Funktionsaufruf weitergeleitet wird.

_#include <iostream>
#include <chrono>

template<typename TimeT = std::chrono::milliseconds>
struct measure
{
    template<typename F, typename ...Args>
    static typename TimeT::rep execution(F&& func, Args&&... args)
    {
        auto start = std::chrono::steady_clock::now();
        std::forward<decltype(func)>(func)(std::forward<Args>(args)...);
        auto duration = std::chrono::duration_cast< TimeT> 
                            (std::chrono::steady_clock::now() - start);
        return duration.count();
    }
};

int main() {
    std::cout << measure<>::execution(functor(dummy)) << std::endl;
}
_

Demo

Nach dem Kommentar von Howard Hinnant ​​ ist es am besten, erst dann aus dem Chronosystem zu fliehen, wenn wir müssen. Die obige Klasse kann dem Benutzer also die Wahl geben, count manuell aufzurufen, indem eine zusätzliche statische Methode bereitgestellt wird (in C++ 14 gezeigt).

_template<typename F, typename ...Args>
static auto duration(F&& func, Args&&... args)
{
    auto start = std::chrono::steady_clock::now();
    std::forward<decltype(func)>(func)(std::forward<Args>(args)...);
    return std::chrono::duration_cast<TimeT>(std::chrono::steady_clock::now()-start);
} 

// call .count() manually later when needed (eg IO)
auto avg = (measure<>::duration(func) + measure<>::duration(func)) / 2.0;
_

und am nützlichsten für Kunden, die

"möchte eine Reihe von Dauern vor der Eingabe/Ausgabe nachbearbeiten (z. B. Durchschnitt)"


Den vollständigen Code finden Sie hier . Mein Versuch, ein Benchmarking-Tool basierend auf Chrono zu erstellen, wird aufgezeichnet hier .


Wenn C++ 17's std::invoke verfügbar ist, kann der Aufruf des Aufrufbaren in execution folgendermaßen erfolgen:

_invoke(forward<decltype(func)>(func), forward<Args>(args)...);
_

callables bereitzustellen, die Zeiger auf Member-Funktionen sind.

257
//***C++11 Style:***
#include <chrono>

std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();

std::cout << "Time difference = " << std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() << "[µs]" << std::endl;
std::cout << "Time difference = " << std::chrono::duration_cast<std::chrono::nanoseconds> (end - begin).count() << "[ns]" << std::endl;
244
user3762106

Wie ich aus Ihrer Frage ersehen kann, möchten Sie die verstrichene Zeit nach der Ausführung eines Codeteils wissen. Ich schätze, Sie würden sich wohl fühlen, wenn Sie die Ergebnisse in Sekunden sehen würden. Versuchen Sie in diesem Fall, die Funktion difftime() wie unten gezeigt zu verwenden. Hoffe das löst dein Problem.

#include <time.h>
#include <stdio.h>

time_t start,end;
time (&start);
.
.
.
<your code>
.
.
.
time (&end);
double dif = difftime (end,start);
printf ("Elasped time is %.2lf seconds.", dif );
57
AKN

Nur Windows: (Das Linux-Tag wurde hinzugefügt, nachdem ich diese Antwort gepostet habe.)

Mit GetTickCount () können Sie die Anzahl der Millisekunden abrufen, die seit dem Systemstart vergangen sind.

long int before = GetTickCount();

// Perform time-consuming operation

long int after = GetTickCount();
31
RvdK

die Zeitfunktion (NULL) gibt die Anzahl der Sekunden zurück, die seit dem 01.01.1970 um 00:00 Uhr vergangen sind. Und weil diese Funktion in Ihrem Programm zu unterschiedlichen Zeiten aufgerufen wird, ist sie immer unterschiedlich Zeit in C++

13
vodkhang

time(NULL) gibt die Anzahl der Sekunden zurück, die seit dem 01.01.1970 um 00:00 ( die Epoche ) vergangen sind. Der Unterschied zwischen den beiden Werten ist also die Anzahl der Sekunden, die Ihre Verarbeitung gedauert hat.

int t0 = time(NULL);
doSomthing();
doSomthingLong();
int t1 = time(NULL);

printf ("time = %d secs\n", t1 - t0);

Sie können mit getttimeofday() feinere Ergebnisse erzielen, wobei die aktuelle Zeit in Sekunden zurückgegeben wird, wie dies bei time() der Fall ist, und auch in Mikrosekunden.

12
philant
struct profiler
{
    std::string name;
    std::chrono::high_resolution_clock::time_point p;
    profiler(std::string const &n) :
        name(n), p(std::chrono::high_resolution_clock::now()) { }
    ~profiler()
    {
        using dura = std::chrono::duration<double>;
        auto d = std::chrono::high_resolution_clock::now() - p;
        std::cout << name << ": "
            << std::chrono::duration_cast<dura>(d).count()
            << std::endl;
    }
};

#define PROFILE_BLOCK(pbn) profiler _pfinstance(pbn)

Verbrauch ist unten ::

{
    PROFILE_BLOCK("Some time");
    // your code or function
}

Dies ähnelt in seinem Umfang RAII

HINWEIS das ist nicht meins, aber ich dachte, dass es hier relevant war

11
user6266295
#include<time.h> // for clock
#include<math.h> // for fmod
#include<cstdlib> //for system
#include <stdio.h> //for delay

using namespace std;

int main()
{


   clock_t t1,t2;

   t1=clock(); // first time capture

   // Now your time spanning loop or code goes here
   // i am first trying to display time elapsed every time loop runs

   int ddays=0; // d prefix is just to say that this variable will be used for display
   int dhh=0;
   int dmm=0;
   int dss=0;

   int loopcount = 1000 ; // just for demo your loop will be different of course

   for(float count=1;count<loopcount;count++)
   {

     t2=clock(); // we get the time now

     float difference= (((float)t2)-((float)t1)); // gives the time elapsed since t1 in milliseconds

    // now get the time elapsed in seconds

    float seconds = difference/1000; // float value of seconds
    if (seconds<(60*60*24)) // a day is not over
    {
        dss = fmod(seconds,60); // the remainder is seconds to be displayed
        float minutes= seconds/60;  // the total minutes in float
        dmm= fmod(minutes,60);  // the remainder are minutes to be displayed
        float hours= minutes/60; // the total hours in float
        dhh= hours;  // the hours to be displayed
        ddays=0;
    }
    else // we have reached the counting of days
    {
        float days = seconds/(24*60*60);
        ddays = (int)(days);
        float minutes= seconds/60;  // the total minutes in float
        dmm= fmod(minutes,60);  // the rmainder are minutes to be displayed
        float hours= minutes/60; // the total hours in float
        dhh= fmod (hours,24);  // the hours to be displayed

    }

    cout<<"Count Is : "<<count<<"Time Elapsed : "<<ddays<<" Days "<<dhh<<" hrs "<<dmm<<" mins "<<dss<<" secs";


    // the actual working code here,I have just put a delay function
    delay(1000);
    system("cls");

 } // end for loop

}// end of main 
9
Eskay

Die von Ihrem zweiten Programm ausgedruckten Werte sind Sekunden und Mikrosekunden.

0 26339 = 0.026'339 s =   26339 µs
4 45025 = 4.045'025 s = 4045025 µs
8
Didier Trosset
#include <ctime>
#include <cstdio>
#include <iostream>
#include <chrono>
#include <sys/time.h>
using namespace std;
using namespace std::chrono;

void f1()
{
  high_resolution_clock::time_point t1 = high_resolution_clock::now();
  high_resolution_clock::time_point t2 = high_resolution_clock::now();
  double dif = duration_cast<nanoseconds>( t2 - t1 ).count();
  printf ("Elasped time is %lf nanoseconds.\n", dif );
}

void f2()
{
  timespec ts1,ts2;
  clock_gettime(CLOCK_REALTIME, &ts1);
  clock_gettime(CLOCK_REALTIME, &ts2);
  double dif = double( ts2.tv_nsec - ts1.tv_nsec );
  printf ("Elasped time is %lf nanoseconds.\n", dif );
}

void f3()
{
  struct timeval t1,t0;
  gettimeofday(&t0, 0);
  gettimeofday(&t1, 0);
  double dif = double( (t1.tv_usec-t0.tv_usec)*1000);
  printf ("Elasped time is %lf nanoseconds.\n", dif );
}
void f4()
{
  high_resolution_clock::time_point t1 , t2;
  double diff = 0;
  t1 = high_resolution_clock::now() ;
  for(int i = 1; i <= 10 ; i++)
  {
    t2 = high_resolution_clock::now() ;
    diff+= duration_cast<nanoseconds>( t2 - t1 ).count();
    t1 = t2;
  }
  printf ("high_resolution_clock:: Elasped time is %lf nanoseconds.\n", diff/10 );
}

void f5()
{
  timespec ts1,ts2;
  double diff = 0;
  clock_gettime(CLOCK_REALTIME, &ts1);
  for(int i = 1; i <= 10 ; i++)
  {
    clock_gettime(CLOCK_REALTIME, &ts2);
    diff+= double( ts2.tv_nsec - ts1.tv_nsec );
    ts1 = ts2;
  }
  printf ("clock_gettime:: Elasped time is %lf nanoseconds.\n", diff/10 );
}

void f6()
{
  struct timeval t1,t2;
  double diff = 0;
  gettimeofday(&t1, 0);
  for(int i = 1; i <= 10 ; i++)
  {
    gettimeofday(&t2, 0);
    diff+= double( (t2.tv_usec-t1.tv_usec)*1000);
    t1 = t2;
  }
  printf ("gettimeofday:: Elasped time is %lf nanoseconds.\n", diff/10 );
}

int main()
{
  //  f1();
  //  f2();
  //  f3();
  f6();
  f4();
  f5();
  return 0;
}
7
Akanksha Gupta

C++ std :: chrono hat den klaren Vorteil, plattformübergreifend zu sein. Im Vergleich zu POSIX clock_gettime () führt dies jedoch auch zu einem erheblichen Overhead. Auf meiner Linux-Box funktionieren alle std::chrono::xxx_clock::now() -Varianten ungefähr gleich:

std::chrono::system_clock::now()
std::chrono::steady_clock::now()
std::chrono::high_resolution_clock::now()

POSIX clock_gettime(CLOCK_MONOTONIC, &time) sollte zwar mit steady_clock::now() identisch sein, ist aber mehr als dreimal schneller!

Hier ist mein Test der Vollständigkeit halber.

#include <stdio.h>
#include <chrono>
#include <ctime>

void print_timediff(const char* prefix, const struct timespec& start, const 
struct timespec& end)
{
    double milliseconds = end.tv_nsec >= start.tv_nsec
                        ? (end.tv_nsec - start.tv_nsec) / 1e6 + (end.tv_sec - start.tv_sec) * 1e3
                        : (start.tv_nsec - end.tv_nsec) / 1e6 + (end.tv_sec - start.tv_sec - 1) * 1e3;
    printf("%s: %lf milliseconds\n", prefix, milliseconds);
}

int main()
{
    int i, n = 1000000;
    struct timespec start, end;

    // Test stopwatch
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i) {
        struct timespec dummy;
        clock_gettime(CLOCK_MONOTONIC, &dummy);
    }
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("clock_gettime", start, end);

    // Test chrono system_clock
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i)
        auto dummy = std::chrono::system_clock::now();
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("chrono::system_clock::now", start, end);

    // Test chrono steady_clock
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i)
        auto dummy = std::chrono::steady_clock::now();
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("chrono::steady_clock::now", start, end);

    // Test chrono high_resolution_clock
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i)
        auto dummy = std::chrono::high_resolution_clock::now();
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("chrono::high_resolution_clock::now", start, end);

    return 0;
}

Und das ist die Ausgabe, die ich bekomme, wenn ich mit gcc7.2 -O3 kompiliere:

clock_gettime: 24.484926 milliseconds
chrono::system_clock::now: 85.142108 milliseconds
chrono::steady_clock::now: 87.295347 milliseconds
chrono::high_resolution_clock::now: 84.437838 milliseconds
4
Alexey Polonsky

Der Funktionsaufruf time(NULL) gibt die Anzahl der Sekunden zurück, die seit dem 1. Januar 1970 vergangen sind. Vielleicht möchten Sie die Differenz zwischen zwei Zeitstempeln ermitteln:

size_t start = time(NULL);
doSomthing();
doSomthingLong();

printf ("**MyProgram::time elapsed= %lds\n", time(NULL) - start);
3
wilhelmtell

Ich musste die Ausführungszeit einzelner Funktionen in einer Bibliothek messen. Ich wollte nicht jeden Aufruf jeder Funktion mit einer Zeitmessfunktion abschließen müssen, da dies hässlich ist und den Aufrufstapel vertieft. Ich wollte auch keinen Timer-Code am oberen und unteren Rand jeder Funktion einfügen, da dies zu Problemen führt, wenn die Funktion beispielsweise vorzeitig beendet oder Ausnahmen ausgelöst werden können. Am Ende habe ich einen Timer erstellt, der seine eigene Lebensdauer zur Zeitmessung verwendet.

Auf diese Weise kann ich die Zeit messen, die ein Codeblock benötigt, indem ich nur eines dieser Objekte am Anfang des fraglichen Codeblocks instanziiere (Funktion oder irgendein Bereich) und dann dem Instanzen-Destruktor erlaube, die seitdem verstrichene Zeit zu messen Konstruktion, wenn die Instanz den Gültigkeitsbereich verlässt. Sie können das vollständige Beispiel finden hier aber die Struktur ist extrem einfach:

template <typename clock_t = std::chrono::steady_clock>
struct scoped_timer {
  using duration_t = typename clock_t::duration;
  const std::function<void(const duration_t&)> callback;
  const std::chrono::time_point<clock_t> start;

  scoped_timer(const std::function<void(const duration_t&)>& finished_callback) :
      callback(finished_callback), start(clock_t::now()) { }
  scoped_timer(std::function<void(const duration_t&)>&& finished_callback) :
      callback(finished_callback), start(clock_t::now()) { }
  ~scoped_timer() { callback(clock_t::now() - start); }
};

Die Struktur ruft Sie auf den bereitgestellten Funktor zurück, wenn dieser außerhalb des Gültigkeitsbereichs liegt, damit Sie mit den Zeitinformationen etwas anfangen können (drucken oder speichern oder was auch immer). Wenn Sie etwas noch Komplexeres tun müssen, können Sie std::bind mit std::placeholders verwenden, um Funktionen mit mehr Argumenten zurückzurufen.

Hier ist ein kurzes Beispiel für die Verwendung:

void test(bool should_throw) {
  scoped_timer<> t([](const scoped_timer<>::duration_t& elapsed) {
    auto e = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(elapsed).count();
    std::cout << "took " << e << "ms" << std::endl;
  });

  std::this_thread::sleep_for(std::chrono::seconds(1));

  if (should_throw)
    throw nullptr;

  std::this_thread::sleep_for(std::chrono::seconds(1));
}

Wenn Sie gezielter vorgehen möchten, können Sie auch new und delete verwenden, um den Timer explizit zu starten und zu stoppen, ohne sich darauf verlassen zu müssen, dass das Scoping dies für Sie erledigt.

2
Kevin Kreiser

Nach dem, was zu sehen ist, speichert tv_sec die verstrichenen Sekunden, während tv_usec die verstrichenen Mikrosekunden separat speichert. Und sie sind nicht die Konvertierungen voneinander. Daher müssen sie in die richtige Einheit geändert und hinzugefügt werden, um die gesamte verstrichene Zeit zu erhalten.

struct timeval startTV, endTV;

gettimeofday(&startTV, NULL); 

doSomething();
doSomethingLong();

gettimeofday(&endTV, NULL); 

printf("**time taken in microseconds = %ld\n",
    (endTV.tv_sec * 1e6 + endTV.tv_usec - (startTV.tv_sec * 1e6 + startTV.tv_usec))
    );
2
Safar Ligal

Intern greift die Funktion auf die Systemuhr zu, weshalb sie bei jedem Aufruf unterschiedliche Werte zurückgibt. Im Allgemeinen kann es bei nicht funktionalen Sprachen zu vielen Nebenwirkungen und versteckten Zuständen in Funktionen kommen, die Sie nicht nur anhand des Funktionsnamens und der Argumente erkennen können.

2
Mike Weller

Unter Linux ist clock_gettime () eine gute Wahl. Sie müssen eine Echtzeitbibliothek (-lrt) verknüpfen.

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>

#define BILLION  1000000000L;

int main( int argc, char **argv )
  {
    struct timespec start, stop;
    double accum;

    if( clock_gettime( CLOCK_REALTIME, &start) == -1 ) {
      perror( "clock gettime" );
      exit( EXIT_FAILURE );
    }

    system( argv[1] );

    if( clock_gettime( CLOCK_REALTIME, &stop) == -1 ) {
      perror( "clock gettime" );
      exit( EXIT_FAILURE );
    }

    accum = ( stop.tv_sec - start.tv_sec )
          + ( stop.tv_nsec - start.tv_nsec )
            / BILLION;
    printf( "%lf\n", accum );
    return( EXIT_SUCCESS );
  }
2
cloudrain21

Wie andere bereits angemerkt haben, hat die time () - Funktion in der C-Standardbibliothek keine bessere Auflösung als eine Sekunde. Die einzige vollständig portable C-Funktion, die möglicherweise eine bessere Auflösung bietet, scheint clock () zu sein, misst jedoch die Prozessorzeit und nicht die Wanduhrzeit. Wenn man sich damit zufrieden gibt, sich auf POSIX-Plattformen (z. B. Linux) zu beschränken, ist die Funktion clock_gettime () eine gute Wahl.

Seit C++ 11 gibt es viel bessere Timing-Funktionen , die eine bessere Auflösung in einer Form bieten, die auf verschiedenen Compilern und Betriebssystemen sehr portabel sein sollte. In ähnlicher Weise bietet die boost :: datetime-Bibliothek gute Timing-Klassen mit hoher Auflösung, die in hohem Maße portierbar sein sollten.

Eine Herausforderung bei der Verwendung einer dieser Einrichtungen ist die Zeitverzögerung, die durch das Abfragen der Systemuhr entsteht. Beim Experimentieren mit clock_gettime (), boost :: datetime und std :: chrono kann diese Verzögerung leicht eine Frage von Mikrosekunden sein. Wenn Sie also die Dauer eines Teils Ihres Codes messen, müssen Sie einen Messfehler von etwa dieser Größe berücksichtigen oder versuchen, diesen Nullfehler auf irgendeine Weise zu korrigieren. Idealerweise möchten Sie möglicherweise mehrere Messungen der von Ihrer Funktion in Anspruch genommenen Zeit erfassen und die durchschnittliche oder maximale/minimale Zeit berechnen, die über viele Läufe hinweg benötigt wird.

Um bei all diesen Problemen mit der Portabilität und dem Sammeln von Statistiken zu helfen, habe ich die cxx-rtimers-Bibliothek entwickelt, die unter Github verfügbar ist und versucht, eine einfache API für das Timing von C++ - Codeblöcken bereitzustellen. und Berichtsstatistiken von mehreren Timern, die in Ihren Code eingebettet sind. Wenn Sie einen C++ 11-Compiler haben, #include <rtimers/cxx11.hpp> und verwenden Sie etwas wie:

void expensiveFunction() {
    static rtimers::cxx11::DefaultTimer timer("expensiveFunc");
    auto scopedStartStop = timer.scopedStart();
    // Do something costly...
}

Beim Beenden des Programms erhalten Sie eine Zusammenfassung der Timing-Statistiken, die in std :: cerr geschrieben wurden, z. B .:

Timer(expensiveFunc): <t> = 6.65289us, std = 3.91685us, 3.842us <= t <= 63.257us (n=731)

dies zeigt die mittlere Zeit, ihre Standardabweichung, die oberen und unteren Grenzen und die Häufigkeit, mit der diese Funktion aufgerufen wurde.

Wenn Sie Linux-spezifische Timing-Funktionen verwenden möchten, können Sie #include <rtimers/posix.hpp>, oder wenn Sie die Boost-Bibliotheken, aber einen älteren C++ - Compiler haben, können Sie #include <rtimers/boost.hpp>. Es gibt auch Versionen dieser Timer-Klassen, mit denen statistische Timing-Informationen aus mehreren Threads erfasst werden können. Es gibt auch Methoden, mit denen Sie den Nullfehler schätzen können, der mit zwei unmittelbar aufeinander folgenden Abfragen der Systemuhr verbunden ist.

2
rwp

Normalerweise benutze ich Folgendes:

#include <chrono>
#include <type_traits>

using perf_clock = std::conditional<
    std::chrono::high_resolution_clock::is_steady,
    std::chrono::high_resolution_clock,
    std::chrono::steady_clock
>::type;

using floating_seconds = std::chrono::duration<double>;

template<class F, class... Args>
floating_seconds run_test(Func&& func, Args&&... args)
{
   const auto t0 = perf_clock::now();
   std::forward<Func>(func)(std::forward<Args>(args)...);
   return floating_seconds(perf_clock::now() - t0);
} 

Es ist dasselbe wie @ nikos-athanasiou vorgeschlagen, außer dass ich die Verwendung einer instationären Uhr vermeide und die schwebende Anzahl von Sekunden als Dauer verwende.

1
oliora

Sie sind dieselben, weil Ihre Funktion doSomething schneller abläuft als die Granularität des Timers. Versuchen:

printf ("**MyProgram::before time= %ld\n", time(NULL));

for(i = 0; i < 1000; ++i) {
    doSomthing();
    doSomthingLong();
}

printf ("**MyProgram::after time= %ld\n", time(NULL));
1
kibibu

Der Grund, warum beide Werte gleich sind, ist, dass Ihr langer Vorgang nicht so lange dauert - weniger als eine Sekunde. Sie können versuchen, einfach eine lange Schleife (für (int i = 0; i <100000000; i ++);) am Ende der Funktion hinzuzufügen, um sicherzustellen, dass dies das Problem ist. Dann können wir fortfahren ...

Sollte sich herausstellen, dass das oben Genannte zutrifft, müssen Sie eine andere Systemfunktion finden (ich verstehe, dass Sie unter Linux arbeiten, daher kann ich Ihnen beim Funktionsnamen nicht helfen), um die Zeit genauer zu messen. Ich bin sicher, dass es eine Funktion gibt, die GetTickCount () unter Linux ähnelt. Sie müssen sie nur finden.

1
David Božjak

Zur Beantwortung von OP's drei spezifische Fragen

"Was ich nicht verstehe ist, warum die Werte im Vorher und Nachher gleich sind? "

Die erste Frage und der Beispielcode zeigen, dass time() eine Auflösung von 1 Sekunde hat, daher muss die Antwort sein, dass die beiden Funktionen in weniger als 1 Sekunde ausgeführt werden. Aber gelegentlich informiert es (anscheinend unlogisch) 1 Sekunde, wenn die beiden Timer-Markierungen eine Sekunde überschreiten.

Im nächsten Beispiel wird gettimeofday() verwendet, das diese Struktur ausfüllt

struct timeval {
    time_t      tv_sec;     /* seconds */
    suseconds_t tv_usec;    /* microseconds */
};

und die zweite Frage fragt: "Wie lese ich ein Ergebnis von **time taken = 0 26339? Bedeutet das 26.339 Nanosekunden = 26,3 ms?"

Meine zweite Antwort ist, dass die benötigte Zeit 0 Sekunden und 26339 Mikrosekunden beträgt, also 0,026339 Sekunden, was das erste Beispiel bestätigt, das in weniger als 1 Sekunde ausgeführt wird.

Die dritte Frage fragt: "Was ist mit **time taken = 4 45025, bedeutet das 4 Sekunden und 25 ms?"

Meine dritte Antwort ist, dass die benötigte Zeit 4 Sekunden und 45025 Mikrosekunden beträgt, dh 4,045025 Sekunden. Dies zeigt, dass OP die Aufgaben geändert hat, die von den beiden Funktionen ausgeführt wurden, die er zuvor zeitlich festgelegt hatte.

0
Weather Vane