std::clock

 

C++

Language

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!= rel_ops::operator> rel_ops::operator<= rel_ops::operator>=

Pairs and tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

Swap, forward and move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

Date and time utilities

time_point (C++11)

duration (C++11)

system_clock (C++11)

steady_clock (C++11)

high_resolution_clock (C++11)

C library facilities

 

C-style date and time utilities

Functions

Time manipulation

difftime

time

clock

Format conversions

asctime

ctime

strftime

wcsftime

gmtime

localtime

mktime

Constants

CLOCKS_PER_SEC

Types

tm

time_t

clock_t

 

Defined in header <ctime>
std::clock_t clock();

Returns the approximate processor time used by the process since the beginning of an implementation-defined era related to the program's execution. To convert result value to seconds divide it by CLOCKS_PER_SEC. Because the beginning of the std::clock era does not have to coincide with the start of the program, only the difference between two values returned by different calls to std::clock is meaningful. If the CPU is shared by other processes, std::clock time may advance slower than wall clock. If the current process is multithreaded and more than one execution core is available, std::clock time may advance faster than wall clock.

Parameters

(none)

Return value

Processor time used by the program so far or (clock_t)(-1) if that information is unavailable.

Notes

On POSIX-compatible systems, clock_gettime with clock id CLOCK_PROCESS_CPUTIME_ID offers better resolution.

The value returned by clock() may wrap around on some implementations. For example, on a machine with 32-bit std::clock_t, it wraps after 2147 seconds or 36 minutes.

clock() is not required to be thread-safe.

Example

This example demonstrates the difference between clock() time and real time

#include <iostream>
#include <chrono>
#include <ctime>
#include <thread>
 
// the function f() does some time-consuming work
void f()
{
    volatile double d;
    for(int n=0; n<10000; ++n)
       for(int m=0; m<10000; ++m)
           d += d*n*m;
}
 
int main()
{
    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();
    std::clock_t c_end = std::clock();
    auto t_end = std::chrono::high_resolution_clock::now();
 
    std::cout << "CPU time used: "
              << 1000.0 * (c_end-c_start) / CLOCKS_PER_SEC
              << " ms" << std::endl;
    std::cout << "Wall clock time passed: "
              << std::chrono::duration_cast<std::chrono::milliseconds>(t_end - t_start).count()
              << " ms" << std::endl;
}

Output:

CPU time used: 1520 ms
Wall clock time passed: 769 ms

See also

ctime	converts a time_t object to a textual representation (function)
time	returns the current time of the system as time since epoch (function)
C documentation for clock