1 /*
2 Copyright (c) 2005-2020 Intel Corporation
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17 #ifndef __TBB_tick_count_H
18 #define __TBB_tick_count_H
19
20 #include "tbb_stddef.h"
21
22 #if _WIN32||_WIN64
23 #include "machine/windows_api.h"
24 #elif __linux__
25 #include <ctime>
26 #else /* generic Unix */
27 #include <sys/time.h>
28 #endif /* (choice of OS) */
29
30 namespace tbb {
31
32 //! Absolute timestamp
33 /** @ingroup timing */
34 class tick_count {
35 public:
36 //! Relative time interval.
37 class interval_t {
38 long long value;
interval_t(long long value_)39 explicit interval_t( long long value_ ) : value(value_) {}
40 public:
41 //! Construct a time interval representing zero time duration
interval_t()42 interval_t() : value(0) {};
43
44 //! Construct a time interval representing sec seconds time duration
45 explicit interval_t( double sec );
46
47 //! Return the length of a time interval in seconds
48 double seconds() const;
49
50 friend class tbb::tick_count;
51
52 //! Extract the intervals from the tick_counts and subtract them.
53 friend interval_t operator-( const tick_count& t1, const tick_count& t0 );
54
55 //! Add two intervals.
56 friend interval_t operator+( const interval_t& i, const interval_t& j ) {
57 return interval_t(i.value+j.value);
58 }
59
60 //! Subtract two intervals.
61 friend interval_t operator-( const interval_t& i, const interval_t& j ) {
62 return interval_t(i.value-j.value);
63 }
64
65 //! Accumulation operator
66 interval_t& operator+=( const interval_t& i ) {value += i.value; return *this;}
67
68 //! Subtraction operator
69 interval_t& operator-=( const interval_t& i ) {value -= i.value; return *this;}
70 private:
ticks_per_second()71 static long long ticks_per_second(){
72 #if _WIN32||_WIN64
73 LARGE_INTEGER qpfreq;
74 int rval = QueryPerformanceFrequency(&qpfreq);
75 __TBB_ASSERT_EX(rval, "QueryPerformanceFrequency returned zero");
76 return static_cast<long long>(qpfreq.QuadPart);
77 #elif __linux__
78 return static_cast<long long>(1E9);
79 #else /* generic Unix */
80 return static_cast<long long>(1E6);
81 #endif /* (choice of OS) */
82 }
83 };
84
85 //! Construct an absolute timestamp initialized to zero.
tick_count()86 tick_count() : my_count(0) {};
87
88 //! Return current time.
89 static tick_count now();
90
91 //! Subtract two timestamps to get the time interval between
92 friend interval_t operator-( const tick_count& t1, const tick_count& t0 );
93
94 //! Return the resolution of the clock in seconds per tick.
resolution()95 static double resolution() { return 1.0 / interval_t::ticks_per_second(); }
96
97 private:
98 long long my_count;
99 };
100
now()101 inline tick_count tick_count::now() {
102 tick_count result;
103 #if _WIN32||_WIN64
104 LARGE_INTEGER qpcnt;
105 int rval = QueryPerformanceCounter(&qpcnt);
106 __TBB_ASSERT_EX(rval, "QueryPerformanceCounter failed");
107 result.my_count = qpcnt.QuadPart;
108 #elif __linux__
109 struct timespec ts;
110 int status = clock_gettime( CLOCK_REALTIME, &ts );
111 __TBB_ASSERT_EX( status==0, "CLOCK_REALTIME not supported" );
112 result.my_count = static_cast<long long>(1000000000UL)*static_cast<long long>(ts.tv_sec) + static_cast<long long>(ts.tv_nsec);
113 #else /* generic Unix */
114 struct timeval tv;
115 int status = gettimeofday(&tv, NULL);
116 __TBB_ASSERT_EX( status==0, "gettimeofday failed" );
117 result.my_count = static_cast<long long>(1000000)*static_cast<long long>(tv.tv_sec) + static_cast<long long>(tv.tv_usec);
118 #endif /*(choice of OS) */
119 return result;
120 }
121
interval_t(double sec)122 inline tick_count::interval_t::interval_t( double sec ) {
123 value = static_cast<long long>(sec*interval_t::ticks_per_second());
124 }
125
126 inline tick_count::interval_t operator-( const tick_count& t1, const tick_count& t0 ) {
127 return tick_count::interval_t( t1.my_count-t0.my_count );
128 }
129
seconds()130 inline double tick_count::interval_t::seconds() const {
131 return value*tick_count::resolution();
132 }
133
134 } // namespace tbb
135
136 #endif /* __TBB_tick_count_H */
137