1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
/************************************************************************************
PublicHeader: OVR
Filename : OVR_Timer.h
Content : Provides static functions for precise timing
Created : September 19, 2012
Notes :
Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
Licensed under the Oculus VR SDK License Version 2.0 (the "License");
you may not use the Oculus VR SDK except in compliance with the License,
which is provided at the time of installation or download, or which
otherwise accompanies this software in either electronic or hard copy form.
You may obtain a copy of the License at
http://www.oculusvr.com/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, the Oculus VR SDK
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
************************************************************************************/
#ifndef OVR_Timer_h
#define OVR_Timer_h
#include "OVR_Types.h"
namespace OVR {
//-----------------------------------------------------------------------------------
// ***** Timer
// Timer class defines a family of static functions used for application
// timing and profiling.
class Timer
{
public:
enum {
MsPerSecond = 1000, // Milliseconds in one second.
MksPerMs = 1000, // Microseconds in one millisecond.
MksPerSecond = MsPerSecond * MksPerMs
};
// ***** Timing APIs for Application
// These APIs should be used to guide animation and other program functions
// that require precision.
// Returns ticks in milliseconds, as a 32-bit number. May wrap around every
// 49.2 days. Use either time difference of two values of GetTicks to avoid
// wrap-around. GetTicksMs may perform better then GetTicks.
static UInt32 OVR_STDCALL GetTicksMs();
// GetTicks returns general-purpose high resolution application timer value,
// measured in microseconds (mks, or 1/1000000 of a second). The actual precision
// is system-specific and may be much lower, such as 1 ms.
static UInt64 OVR_STDCALL GetTicks();
// Returns global high-resolution application timer in seconds.
static double OVR_STDCALL GetSeconds();
// ***** Profiling APIs.
// These functions should be used for profiling, but may have system specific
// artifacts that make them less appropriate for general system use.
// On Win32, for example these rely on QueryPerformanceConter may have
// problems with thread-core switching and power modes.
// Return a hi-res timer value in mks (1/1000000 of a sec).
// Generally you want to call this at the start and end of an
// operation, and pass the difference to
// TicksToSeconds() to find out how long the operation took.
static UInt64 OVR_STDCALL GetProfileTicks();
// More convenient zero-based profile timer in seconds. First call initializes
// the "zero" value; future calls return the difference. Not thread safe for first call.
// Due to low precision of Double, may malfunction after long runtime.
static double OVR_STDCALL GetProfileSeconds();
// Get the raw cycle counter value, providing the maximum possible timer resolution.
static UInt64 OVR_STDCALL GetRawTicks();
static UInt64 OVR_STDCALL GetRawFrequency();
// ***** Tick and time unit conversion.
// Convert micro-second ticks value into seconds value.
static inline double TicksToSeconds(UInt64 ticks)
{
return static_cast<double>(ticks) * (1.0 / (double)MksPerSecond);
}
// Convert Raw or frequency-unit ticks to seconds based on specified frequency.
static inline double RawTicksToSeconds(UInt64 rawTicks, UInt64 rawFrequency)
{
return static_cast<double>(rawTicks) * rawFrequency;
}
private:
friend class System;
// System called during program startup/shutdown.
static void initializeTimerSystem();
static void shutdownTimerSystem();
};
// Global high-resolution time in seconds. This is intended to replace Timer class in OVR.
double ovr_GetTimeInSeconds();
} // OVR::Timer
#endif
|
