home | help 
std::clock(3)		       C++ Standard Libary		   std::clock(3)

NAME
     std::clock - std::clock

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

	Returns the approximate processor time used by the process since the be-
     ginning of an
	implementation-defined	era  related to the program's execution. To con-
     vert result
	value to seconds divide it by CLOCKS_PER_SEC.

	Only the difference between two values returned by  different  calls  to
     std::clock is
	meaningful,  as the beginning of the std::clock era does not have to co-
     incide with
	the start of the program. std::clock time may advance faster  or  slower
     than the wall
	clock,	depending on the execution resources given to the program by the
     operating
	system. For example, if the CPU is shared by other processes, std::clock
     time may
	advance slower than wall clock.  On  the  other  hand,	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  std::clock_t(-1)	if  that
     information is
	unavailable or its value cannot be represented.

Exceptions
	Throws nothing.

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 non-conforming
	implementations. For example, on such an implementation, if std::clock_t
     is a signed
	32-bit integer and CLOCKS_PER_SEC is 1'000'000, it will wrap after about
     2147
	seconds (about 36 minutes).

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

     // Run this code

      #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)
	      {
		  double diff = d * n * m;
		  d = diff + d;
	      }
      }

      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';
      }

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

See also
	ctime converts a std::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

http://cppreference.com 	   2024.06.10			   std::clock(3)
home | help