Skip to content

Commit 4b7c63b

Browse files
Im-dexIm-dex
committed
QPC usage replaced by std::chrono
1 parent 3460025 commit 4b7c63b

File tree

13 files changed

+208
-268
lines changed

13 files changed

+208
-268
lines changed

‎code/engine/xrCore/CMakeLists.txt

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -111,4 +111,5 @@ add_library(xrCore SHARED ${COMPRESSOR_LZ} ${COMPRESSOR_LZO} ${COMPRESSOR_RT}
111111
${OS}
112112

113113
${SMEM_STR_LIB})
114-
target_link_libraries(xrCore dxerr2015 version dbghelp winmm faultrep psapi)
114+
target_link_libraries(xrCore PUBLIC dxerr2015 version dbghelp winmm faultrep psapi
115+
PRIVATE PowrProf)

‎code/engine/xrCore/FTimer.cpp

Lines changed: 16 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,45 +1,39 @@
11
#include "stdafx.h"
2-
#pragma hdrstop
32

43
XRCORE_API BOOL g_bEnableStatGather = FALSE;
54

6-
CStatTimer::CStatTimer() {
7-
accum = 0;
8-
result = 0.f;
9-
count = 0;
10-
}
11-
125
void CStatTimer::FrameStart() {
13-
accum = 0;
6+
accum = Duration();
147
count = 0;
158
}
9+
1610
void CStatTimer::FrameEnd() {
17-
float _time = 1000.f * float(double(accum) / double(CPU::qpc_freq));
18-
if (_time > result)
19-
result = _time;
11+
const float time = GetElapsed_sec();
12+
if (time > result)
13+
result = time;
2014
else
21-
result = 0.99f * result + 0.01f * _time;
15+
result = 0.99f * result + 0.01f * time;
2216
}
2317

2418
XRCORE_API pauseMngr g_pauseMngr;
2519

26-
pauseMngr::pauseMngr() : m_paused(FALSE) { m_timers.reserve(3); }
20+
pauseMngr::pauseMngr() : paused(false) { m_timers.reserve(3); }
2721

28-
void pauseMngr::Pause(BOOL b) {
29-
if (m_paused == b)
22+
void pauseMngr::Pause(const bool b) {
23+
if (paused == b)
3024
return;
3125

32-
xr_vector<CTimer_paused*>::iterator it = m_timers.begin();
33-
for (; it != m_timers.end(); ++it)
34-
(*it)->Pause(b);
26+
for (auto& timer : m_timers) {
27+
timer->Pause(b);
28+
}
3529

36-
m_paused = b;
30+
paused = b;
3731
}
3832

39-
void pauseMngr::Register(CTimer_paused* t) { m_timers.push_back(t); }
33+
void pauseMngr::Register(CTimer_paused& t) { m_timers.push_back(&t); }
4034

41-
void pauseMngr::UnRegister(CTimer_paused* t) {
42-
xr_vector<CTimer_paused*>::iterator it = std::find(m_timers.begin(), m_timers.end(), t);
35+
void pauseMngr::UnRegister(CTimer_paused& t) {
36+
const auto it = std::find(m_timers.cbegin(), m_timers.cend(), &t);
4337
if (it != m_timers.end())
4438
m_timers.erase(it);
4539
}

‎code/engine/xrCore/FTimer.h

Lines changed: 89 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -1,173 +1,166 @@
1-
#ifndef FTimerH
2-
#define FTimerH
31
#pragma once
42

53
class CTimer_paused;
64

75
class XRCORE_API pauseMngr {
86
xr_vector<CTimer_paused*> m_timers;
9-
BOOL m_paused;
10-
7+
bool paused;
118
public:
129
pauseMngr();
13-
BOOL Paused() { return m_paused; };
14-
void Pause(BOOL b);
15-
void Register(CTimer_paused* t);
16-
void UnRegister(CTimer_paused* t);
10+
bool Paused() const { return paused; }
11+
void Pause(const bool b);
12+
void Register(CTimer_paused& t);
13+
void UnRegister(CTimer_paused& t);
1714
};
1815

1916
extern XRCORE_API pauseMngr g_pauseMngr;
2017

2118
class XRCORE_API CTimerBase {
19+
public:
20+
using Clock = std::chrono::high_resolution_clock;
21+
using Time = std::chrono::time_point<Clock>;
22+
using Duration = Time::duration;
2223
protected:
23-
u64 qwStartTime;
24-
u64 qwPausedTime;
25-
u64 qwPauseAccum;
26-
BOOL bPause;
24+
Time startTime;
25+
Duration pauseDuration;
26+
Duration pauseAccum;
27+
bool paused;
2728

2829
public:
29-
CTimerBase() : qwStartTime(0), qwPausedTime(0), qwPauseAccum(0), bPause(FALSE) {}
30-
ICF void Start() {
31-
if (bPause)
30+
CTimerBase() : startTime(), pauseDuration(), pauseAccum(), paused(false) {}
31+
void Start() {
32+
if (paused)
3233
return;
33-
qwStartTime = CPU::QPC() - qwPauseAccum;
34+
startTime = Clock::now() - pauseAccum;
3435
}
35-
ICF u64 GetElapsed_ticks() const {
36-
if (bPause)
37-
return qwPausedTime;
36+
37+
Duration getElapsedTime() const {
38+
if (paused)
39+
return pauseDuration;
3840
else
39-
return CPU::QPC() - qwStartTime - CPU::qpc_overhead - qwPauseAccum;
41+
return Clock::now() - startTime - pauseAccum;
4042
}
41-
IC u32 GetElapsed_ms() const { return u32(GetElapsed_ticks() * u64(1000) / CPU::qpc_freq); }
42-
IC float GetElapsed_sec() const {
43-
FPU::m64r();
44-
float _result = float(double(GetElapsed_ticks()) / double(CPU::qpc_freq));
45-
FPU::m24r();
46-
return _result;
43+
44+
u64 GetElapsed_ms() const {
45+
using namespace std::chrono;
46+
return duration_cast<milliseconds>(getElapsedTime()).count();
47+
}
48+
49+
float GetElapsed_sec() const {
50+
using namespace std::chrono;
51+
const auto nanos = duration_cast<nanoseconds>(getElapsedTime()).count();
52+
return float(nanos) / 1000000000.0;
4753
}
48-
IC void Dump() const { Msg("* Elapsed time (sec): %f", GetElapsed_sec()); }
54+
55+
void Dump() const { Msg("* Elapsed time (sec): %f", GetElapsed_sec()); }
4956
};
5057

5158
class XRCORE_API CTimer : public CTimerBase {
52-
typedef CTimerBase inherited;
53-
5459
float m_time_factor;
55-
u64 m_real_ticks;
56-
u64 m_ticks;
57-
58-
IC u64 GetElapsed_ticks(const u64& current_ticks) const {
59-
u64 delta = current_ticks - m_real_ticks;
60-
double delta_d = (double)delta;
61-
double time_factor_d = time_factor();
62-
double time = delta_d * time_factor_d + .5;
63-
u64 result = (u64)time;
64-
return (m_ticks + result);
60+
Duration realTime;
61+
Duration time;
62+
63+
Duration getElapsedTime(const Duration current) const {
64+
const auto delta = current - realTime;
65+
const auto deltaD = double(delta.count());
66+
const auto time_factor_d = double(time_factor());
67+
const double time = deltaD * time_factor_d + .5;
68+
const auto result = u64(time);
69+
return Duration(result);
6570
}
6671

6772
public:
68-
IC CTimer() : m_time_factor(1.f), m_real_ticks(0), m_ticks(0) {}
73+
CTimer() : m_time_factor(1.f), realTime(), time() {}
6974

70-
ICF void Start() {
71-
if (bPause)
75+
void Start() {
76+
if (paused)
7277
return;
7378

74-
inherited::Start();
75-
76-
m_real_ticks = 0;
77-
m_ticks = 0;
79+
__super::Start();
7880
}
7981

80-
IC const float& time_factor() const { return (m_time_factor); }
82+
float time_factor() const { return m_time_factor; }
8183

82-
IC void time_factor(const float& time_factor) {
83-
u64 current = inherited::GetElapsed_ticks();
84-
m_ticks = GetElapsed_ticks(current);
85-
m_real_ticks = current;
84+
void time_factor(const float time_factor) {
85+
const auto current = __super::getElapsedTime();
86+
time = getElapsedTime(current);
87+
realTime = current;
8688
m_time_factor = time_factor;
8789
}
8890

89-
IC u64 GetElapsed_ticks() const {
90-
FPU::m64r();
91-
u64 result = GetElapsed_ticks(inherited::GetElapsed_ticks());
92-
FPU::m24r();
93-
94-
return (result);
95-
}
96-
97-
IC u32 GetElapsed_ms() const { return (u32(GetElapsed_ticks() * u64(1000) / CPU::qpc_freq)); }
98-
99-
IC float GetElapsed_sec() const {
100-
FPU::m64r();
101-
float result = float(double(GetElapsed_ticks()) / double(CPU::qpc_freq));
102-
FPU::m24r();
103-
return (result);
91+
Duration getElapsedTime() const {
92+
return __super::getElapsedTime();
10493
}
105-
106-
IC void Dump() const { Msg("* Elapsed time (sec): %f", GetElapsed_sec()); }
10794
};
10895

10996
class XRCORE_API CTimer_paused_ex : public CTimer {
110-
u64 save_clock;
111-
97+
Time save_clock;
11298
public:
113-
CTimer_paused_ex() {}
99+
CTimer_paused_ex() : save_clock() {}
114100
virtual ~CTimer_paused_ex() {}
115-
IC BOOL Paused() const { return bPause; }
116-
IC void Pause(BOOL b) {
117-
if (bPause == b)
101+
bool Paused() const { return paused; }
102+
103+
void Pause(const bool b) {
104+
if (paused == b)
118105
return;
119106

120-
u64 _current = CPU::QPC() - CPU::qpc_overhead;
107+
const auto current = Clock::now();
121108
if (b) {
122-
save_clock = _current;
123-
qwPausedTime = CTimerBase::GetElapsed_ticks();
109+
save_clock = current;
110+
pauseDuration = CTimerBase::getElapsedTime();
124111
} else {
125-
qwPauseAccum += _current - save_clock;
112+
pauseAccum += current - save_clock;
126113
}
127-
bPause = b;
114+
paused = b;
128115
}
129116
};
130117

131118
class XRCORE_API CTimer_paused : public CTimer_paused_ex {
132119
public:
133-
CTimer_paused() { g_pauseMngr.Register(this); }
134-
virtual ~CTimer_paused() { g_pauseMngr.UnRegister(this); }
120+
CTimer_paused() { g_pauseMngr.Register(*this); }
121+
virtual ~CTimer_paused() { g_pauseMngr.UnRegister(*this); }
135122
};
136123

137124
extern XRCORE_API BOOL g_bEnableStatGather;
125+
138126
class XRCORE_API CStatTimer {
139127
public:
128+
using Duration = CTimerBase::Duration;
129+
140130
CTimer T;
141-
u64 accum;
131+
Duration accum;
142132
float result;
143133
u32 count;
144134

145-
public:
146-
CStatTimer();
135+
CStatTimer() : T(), accum(), result(.0f), count(0) {}
147136
void FrameStart();
148137
void FrameEnd();
149138

150-
ICF void Begin() {
139+
void Begin() {
151140
if (!g_bEnableStatGather)
152141
return;
153142
count++;
154143
T.Start();
155144
}
156-
ICF void End() {
145+
146+
void End() {
157147
if (!g_bEnableStatGather)
158148
return;
159-
accum += T.GetElapsed_ticks();
149+
accum += T.getElapsedTime();
150+
}
151+
152+
Duration getElapsedTime() const {
153+
return accum;
160154
}
161155

162-
ICF u64 GetElapsed_ticks() const { return accum; }
156+
u64 GetElapsed_ms() const {
157+
using namespace std::chrono;
158+
return duration_cast<milliseconds>(getElapsedTime()).count();
159+
}
163160

164-
IC u32 GetElapsed_ms() const { return u32(GetElapsed_ticks() * u64(1000) / CPU::qpc_freq); }
165-
IC float GetElapsed_sec() const {
166-
FPU::m64r();
167-
float _result = float(double(GetElapsed_ticks()) / double(CPU::qpc_freq));
168-
FPU::m24r();
169-
return _result;
161+
float GetElapsed_sec() const {
162+
using namespace std::chrono;
163+
const auto nanos = duration_cast<nanoseconds>(getElapsedTime()).count();
164+
return float(nanos) / 1000000000.0;
170165
}
171166
};
172-
173-
#endif // FTimerH

0 commit comments

Comments
 (0)