std:: clock

Gibt die ungefähre Prozessorzeit zurück, die vom Prozess seit Beginn einer implementationsdefinierten Ära in Bezug auf die Programmausführung verwendet wurde. Um den Ergebniswert in Sekunden umzuwandeln, teilen Sie ihn durch CLOCKS_PER_SEC .

Nur die Differenz zwischen zwei Werten, die durch verschiedene Aufrufe von std::clock zurückgegeben werden, ist aussagekräftig, da der Beginn der std::clock -Ära nicht mit dem Start des Programms übereinstimmen muss.

std::clock Zeit kann schneller oder langsamer fortschreiten als die Wanduhr, abhängig von den Ausführungsressourcen, die dem Programm vom Betriebssystem zugewiesen werden. Beispielsweise, wenn die CPU von anderen Prozessen gemeinsam genutzt wird, kann die std::clock Zeit langsamer fortschreiten als die Wanduhr. Andererseits, wenn der aktuelle Prozess multithreaded ist und mehr als ein Ausführungskern verfügbar ist, kann die std::clock Zeit schneller fortschreiten als die Wanduhr.

Rückgabewert

Bisher vom Programm verwendete Prozessorzeit.

• Falls die verwendete Prozessorzeit nicht verfügbar ist, wird ( std:: clock_t ) ( - 1 ) zurückgegeben.
• Falls der Wert der verwendeten Prozessorzeit nicht durch std::clock_t dargestellt werden kann, wird ein nicht spezifizierter Wert zurückgegeben.

Exceptions

Wirft nichts.

Hinweise

Auf POSIX-kompatiblen Systemen bietet clock_gettime mit der Clock-ID CLOCK_PROCESS_CPUTIME_ID eine bessere Auflösung.

Der von clock() zurückgegebene Wert kann auf einigen Implementierungen umlaufen. Zum Beispiel wird auf einer solchen Implementierung, wenn std::clock_t ein vorzeichenbehafteter 32-Bit-Integer ist und CLOCKS_PER_SEC den Wert 1 '000' 000 hat, der Wert nach etwa 2147 Sekunden (etwa 36 Minuten) umlaufen.

Beispiel

#include <chrono>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <thread>
// The function f() does some time-consuming work.
void f()
{
    volatile double d = 0;
    for (int n = 0; n != 10000; ++n)
        for (int m = 0; m != 10000; ++m)
            d += d * n * m;
}
int main()
{
    const std::clock_t c_start = std::clock();
    auto t_start = std::chrono::high_resolution_clock::now();
    std::thread t1(f);
    std::thread t2(f); // f() is called on two threads
    t1.join();
    t2.join();
    const std::clock_t c_end = std::clock();
    const auto t_end = std::chrono::high_resolution_clock::now();
    std::cout << std::fixed << std::setprecision(2) << "CPU time used: "
              << 1000.0 * (c_end - c_start) / CLOCKS_PER_SEC << "ms\n"
              << "Wall clock time passed: "
              << std::chrono::duration<double, std::milli>(t_end - t_start) << '\n';
}

CPU time used: 1590.00ms
Wall clock time passed: 808.23ms

Siehe auch