.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation
..
.. SPDX-License-Identifier: CC-BY-4.0

================
tick_count class
================
**[timing.tick_count]**

A ``tick_count`` is an absolute wall clock timestamp. Two ``tick_count``
objects can be subtracted to compute wall clock
duration ``tick_count::interval_t``, which can be converted to seconds.

.. code:: cpp

   namespace tbb {

       class tick_count {
       public:
           class interval_t;
           tick_count();
           tick_count( const tick_count& );
           ~tick_count();
           tick_count& operator=( const tick_count& );
           static tick_count now();
           static double resolution();
       };

   } // namespace tbb

``tick_count()``
  Constructs ``tick_count`` with an unspecified wall clock timestamp.

``tick_count( const tick_count& )``
  Constructs ``tick_count`` with the timestamp of the given ``tick_count``.

``~tick_count()``
  Destructor.

``tick_count& operator=( const tick_count& )``
  Assigns the timestamp of one ``tick_count`` to another.

``static tick_count now()``
  Returns a ``tick_count`` object that represents the current wall clock timestamp.

``static double resolution()``
  Returns the resolution of the clock used by ``tick_count``, in seconds.


============================
tick_count::interval_t class
============================
**[timing.tick_count.interval_t]**

A ``tick_count::interval_t`` represents wall clock duration.

.. code:: cpp

   namespace tbb {

       class tick_count::interval_t {
       public:
           interval_t();
           explicit interval_t( double );
           ~interval_t();
           interval_t& operator=( const interval_t& );
           interval_t& operator+=( const interval_t& );
           interval_t& operator-=( const interval_t& );
           double seconds() const;
       };

   } // namespace tbb


``interval_t()``
  Constructs ``interval_t`` representing zero time duration.

``explicit interval_t( double )``
  Constructs ``interval_t`` representing the specified number of seconds.

``~interval_t()``
  Destructor.

``interval_t& operator=( const interval_t& )``
  Assigns the wall clock duration of one ``interval_t`` to another.

``interval_t& operator+=( const interval_t& )``
  Increases the duration to the given ``interval_t``, and returns ``*this``.

``interval_t& operator-=( const interval_t& )``
  Decreases the duration to the given ``interval_t``, and returns ``*this``.

``double seconds() const``
  Returns the duration measured in seconds.


====================
Non-member functions
====================
**[timing.tick_count.nonmember]**

These functions provide arithmetic binary operations with wall clock timestamps and durations.

.. code:: cpp

   tbb::tick_count::interval_t operator-( const tbb::tick_count&, const tbb::tick_count& );
   tbb::tick_count::interval_t operator+( const tbb::tick_count::interval_t&, const tbb::tick_count::interval_t& );
   tbb::tick_count::interval_t operator-( const tbb::tick_count::interval_t&, const tbb::tick_count::interval_t& );

The namespace where these functions are defined is unspecified as long as they may be used in respective binary operation expressions on ``tick_count`` and ``tick_count::interval_t`` objects. 
For example, an implementation may define the classes and functions in the same unspecified internal namespace, 
and define  ``tbb::tick_count`` as a type alias for which the non-member functions are reachable only via argument-dependent lookup. 


``tbb::tick_count::interval_t operator-( const tbb::tick_count&, const tbb::tick_count& )``
  Returns ``interval_t`` representing the duration between two given wall clock timestamps.

``tbb::tick_count::interval_t operator+( const tbb::tick_count::interval_t&, const tbb::tick_count::interval_t& )``
  Returns ``interval_t`` representing the sum of two given intervals.

``tbb::tick_count::interval_t operator-( const tbb::tick_count::interval_t&, const tbb::tick_count::interval_t& )``
  Returns ``interval_t`` representing the difference of two given intervals.