}
}
-u32 RemoteClient::uptime() const
+u64 RemoteClient::uptime() const
{
- return porting::getTime(PRECISION_SECONDS) - m_connection_time;
+ return porting::getTimeS() - m_connection_time;
}
ClientInterface::ClientInterface(con::Connection* con)
m_version_patch(0),
m_full_version("unknown"),
m_deployed_compression(0),
- m_connection_time(porting::getTime(PRECISION_SECONDS))
+ m_connection_time(porting::getTimeS())
{
}
~RemoteClient()
{ serialization_version = m_pending_serialization_version; }
/* get uptime */
- u32 uptime() const;
+ u64 uptime() const;
/* set version information */
void setVersionInfo(u8 major, u8 minor, u8 patch, const std::string &full)
/*
time this client was created
*/
- const u32 m_connection_time;
+ const u64 m_connection_time;
};
class ClientInterface {
if (hovered != NULL) {
s32 id = hovered->getID();
- u32 delta = 0;
+ u64 delta = 0;
if (id == -1) {
m_old_tooltip_id = id;
m_old_tooltip = L"";
m_doubleclickdetect[1].time = porting::getTimeMs();
}
else if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP) {
- u32 delta = porting::getDeltaMs(m_doubleclickdetect[0].time, porting::getTimeMs());
+ u64 delta = porting::getDeltaMs(m_doubleclickdetect[0].time, porting::getTimeMs());
if (delta > 400) {
return false;
}
v2s32 m_old_pointer; // Mouse position after previous mouse event
gui::IGUIStaticText *m_tooltip_element;
- u32 m_tooltip_show_delay;
- s64 m_hovered_time;
+ u64 m_tooltip_show_delay;
+ u64 m_hovered_time;
s32 m_old_tooltip_id;
std::wstring m_old_tooltip;
}
struct MeshTimeInfo {
- s64 time;
+ u64 time;
scene::IMesh *mesh;
};
gui::IGUIFont *OverrideFont, *LastBreakFont;
IOSOperator* Operator;
- u32 BlinkStartTime;
+ u64 BlinkStartTime;
s32 CursorPos;
s32 HScrollPos, VScrollPos; // scroll position in characters
u32 Max;
time_until_purge *= 1000; // seconds -> milliseconds
- u32 curr_time = porting::getTime(PRECISION_MILLI);
+ u64 curr_time = porting::getTimeMs();
u32 prev_unprocessed = m_unprocessed_count;
m_unprocessed_count = m_transforming_liquid.size();
private:
f32 m_transforming_liquid_loop_count_multiplier;
u32 m_unprocessed_count;
- u32 m_inc_trending_up_start_time; // milliseconds
+ u64 m_inc_trending_up_start_time; // milliseconds
bool m_queue_size_timer_started;
DISABLE_CLASS_COPY(Map);
// Seconds from last receive
float m_timeout_counter;
- u32 m_last_timeout_check;
+ u64 m_last_timeout_check;
};
class UDPPeer : public Peer
static Profiler main_profiler;
Profiler *g_profiler = &main_profiler;
+ScopeProfiler::ScopeProfiler(
+ Profiler *profiler, const std::string &name, ScopeProfilerType type)
+ : m_profiler(profiler), m_name(name), m_timer(NULL), m_type(type)
+{
+ if (m_profiler)
+ m_timer = new TimeTaker(m_name);
+}
+
+ScopeProfiler::~ScopeProfiler()
+{
+ if (!m_timer)
+ return;
+
+ float duration_ms = m_timer->stop(true);
+ float duration = duration_ms / 1000.0;
+ if (m_profiler) {
+ switch (m_type) {
+ case SPT_ADD:
+ m_profiler->add(m_name, duration);
+ break;
+ case SPT_AVG:
+ m_profiler->avg(m_name, duration);
+ break;
+ case SPT_GRAPH_ADD:
+ m_profiler->graphAdd(m_name, duration);
+ break;
+ }
+ }
+ delete m_timer;
+}
{
public:
ScopeProfiler(Profiler *profiler, const std::string &name,
- enum ScopeProfilerType type = SPT_ADD):
- m_profiler(profiler),
- m_name(name),
- m_timer(NULL),
- m_type(type)
- {
- if(m_profiler)
- m_timer = new TimeTaker(m_name.c_str());
- }
- // name is copied
- ScopeProfiler(Profiler *profiler, const char *name,
- enum ScopeProfilerType type = SPT_ADD):
- m_profiler(profiler),
- m_name(name),
- m_timer(NULL),
- m_type(type)
- {
- if(m_profiler)
- m_timer = new TimeTaker(m_name.c_str());
- }
- ~ScopeProfiler()
- {
- if(m_timer)
- {
- float duration_ms = m_timer->stop(true);
- float duration = duration_ms / 1000.0;
- if(m_profiler){
- switch(m_type){
- case SPT_ADD:
- m_profiler->add(m_name, duration);
- break;
- case SPT_AVG:
- m_profiler->avg(m_name, duration);
- break;
- case SPT_GRAPH_ADD:
- m_profiler->graphAdd(m_name, duration);
- break;
- }
- }
- delete m_timer;
- }
- }
+ ScopeProfilerType type = SPT_ADD);
+ ~ScopeProfiler();
private:
Profiler *m_profiler;
std::string m_name;
m_key_events[1].x = m_move_downlocation.X;
m_key_events[1].y = m_move_downlocation.Y;
- u32 delta = porting::getDeltaMs(m_key_events[0].down_time, porting::getTimeMs());
+ u64 delta = porting::getDeltaMs(m_key_events[0].down_time, porting::getTimeMs());
if (delta > 400)
return false;
(!m_move_has_really_moved) &&
(!m_move_sent_as_mouse_event)) {
- u32 delta = porting::getDeltaMs(m_move_downtime, porting::getTimeMs());
+ u64 delta = porting::getDeltaMs(m_move_downtime, porting::getTimeMs());
if (delta > MIN_DIG_TIME_MS) {
m_shootline = m_device
{
DSTACK(FUNCTION_NAME);
- u32 t1 = porting::getTime(PRECISION_MILLI);
+ u64 t1 = porting::getTimeMs();
TestGameDef gamedef;
g_logger.setLevelSilenced(LL_ERROR, true);
num_total_tests_run += testmods[i]->num_tests_run;
}
- u32 tdiff = porting::getTime(PRECISION_MILLI) - t1;
+ u64 tdiff = porting::getTimeMs() - t1;
g_logger.setLevelSilenced(LL_ERROR, false);
bool TestBase::testModule(IGameDef *gamedef)
{
rawstream << "======== Testing module " << getName() << std::endl;
- u32 t1 = porting::getTime(PRECISION_MILLI);
+ u64 t1 = porting::getTimeMs();
runTests(gamedef);
- u32 tdiff = porting::getTime(PRECISION_MILLI) - t1;
+ u64 tdiff = porting::getTimeMs() - t1;
rawstream << "======== Module " << getName() << " "
<< (num_tests_failed ? "failed" : "passed") << " (" << num_tests_failed
<< " failures / " << num_tests_run << " tests) - " << tdiff
// Runs a unit test and reports results
#define TEST(fxn, ...) do { \
- u32 t1 = porting::getTime(PRECISION_MILLI); \
+ u64 t1 = porting::getTimeMs(); \
try { \
fxn(__VA_ARGS__); \
rawstream << "[PASS] "; \
num_tests_failed++; \
} \
num_tests_run++; \
- u32 tdiff = porting::getTime(PRECISION_MILLI) - t1; \
+ u64 tdiff = porting::getTimeMs() - t1; \
rawstream << #fxn << " - " << tdiff << "ms" << std::endl; \
} while (0)
#include "../log.h"
#include <ostream>
-TimeTaker::TimeTaker(const char *name, u32 *result, TimePrecision prec)
+TimeTaker::TimeTaker(const std::string &name, u64 *result, TimePrecision prec)
{
m_name = name;
m_result = result;
m_time1 = porting::getTime(prec);
}
-u32 TimeTaker::stop(bool quiet)
+u64 TimeTaker::stop(bool quiet)
{
- if(m_running)
- {
- u32 time2 = porting::getTime(m_precision);
- u32 dtime = time2 - m_time1;
- if(m_result != NULL)
- {
+ if (m_running) {
+ u64 dtime = porting::getTime(m_precision) - m_time1;
+ if (m_result != NULL) {
(*m_result) += dtime;
- }
- else
- {
+ } else {
if (!quiet) {
static const char* const units[] = {
"s" /* PRECISION_SECONDS */,
return 0;
}
-u32 TimeTaker::getTimerTime()
+u64 TimeTaker::getTimerTime()
{
- u32 time2 = porting::getTime(m_precision);
- u32 dtime = time2 - m_time1;
- return dtime;
+ return porting::getTime(m_precision) - m_time1;
}
class TimeTaker
{
public:
- TimeTaker(const char *name, u32 *result=NULL,
- TimePrecision=PRECISION_MILLI);
+ TimeTaker(const std::string &name, u64 *result=NULL,
+ TimePrecision prec=PRECISION_MILLI);
~TimeTaker()
{
stop();
}
- u32 stop(bool quiet=false);
+ u64 stop(bool quiet=false);
- u32 getTimerTime();
+ u64 getTimerTime();
private:
- const char *m_name;
- u32 m_time1;
+ std::string m_name;
+ u64 m_time1;
bool m_running;
TimePrecision m_precision;
- u32 *m_result;
+ u64 *m_result;
};
#endif
/*
Debug stuff
*/
-u32 addarea_time = 0;
-u32 emerge_time = 0;
-u32 emerge_load_time = 0;
-u32 clearflag_time = 0;
-//u32 getwaterpressure_time = 0;
-//u32 spreadwaterpressure_time = 0;
-u32 updateareawaterpressure_time = 0;
-u32 flowwater_pre_time = 0;
+u64 addarea_time = 0;
+u64 emerge_time = 0;
+u64 emerge_load_time = 0;
+u64 clearflag_time = 0;
VoxelManipulator::VoxelManipulator():
/*
Debug stuff
*/
-extern u32 emerge_time;
-extern u32 emerge_load_time;
+extern u64 emerge_time;
+extern u64 emerge_load_time;
/*
This class resembles aabbox3d<s16> a lot, but has inclusive