mirror of
https://github.com/moses-smt/mosesdecoder.git
synced 2024-12-25 21:03:22 +03:00
124 lines
2.9 KiB
C++
124 lines
2.9 KiB
C++
#include "Timer.h"
|
|
#include "Util.h"
|
|
|
|
#if !defined(_WIN32) && !defined(_WIN64)
|
|
#include <sys/resource.h>
|
|
#include <sys/time.h>
|
|
#endif
|
|
|
|
#if defined __MINGW32__
|
|
#include <sys/time.h>
|
|
#endif // defined
|
|
|
|
namespace
|
|
{
|
|
|
|
#if (!defined(_WIN32) && !defined(_WIN64)) || defined __MINGW32__
|
|
uint64_t GetMicroSeconds(const struct timeval& tv)
|
|
{
|
|
return static_cast<uint64_t>(tv.tv_sec) * 1000000 + tv.tv_usec;
|
|
}
|
|
|
|
uint64_t GetTimeOfDayMicroSeconds()
|
|
{
|
|
struct timeval tv;
|
|
gettimeofday(&tv, NULL);
|
|
return static_cast<uint64_t>(tv.tv_sec) * 1000000 + tv.tv_usec;
|
|
}
|
|
#endif
|
|
|
|
} // namespace
|
|
|
|
namespace MosesTuning
|
|
{
|
|
|
|
|
|
void Timer::GetCPUTimeMicroSeconds(Timer::CPUTime* cpu_time) const
|
|
{
|
|
#if !defined(_WIN32) && !defined(_WIN64)
|
|
struct rusage usage;
|
|
if (getrusage(RUSAGE_SELF, &usage)) {
|
|
TRACE_ERR("Error occurred: getrusage().\n");
|
|
exit(1);
|
|
}
|
|
cpu_time->user_time = GetMicroSeconds(usage.ru_utime);
|
|
cpu_time->sys_time = GetMicroSeconds(usage.ru_stime);
|
|
#else // Windows
|
|
// Not implemented yet.
|
|
// TODO: implement the Windows version using native APIs.
|
|
#endif
|
|
}
|
|
|
|
double Timer::get_elapsed_cpu_time() const
|
|
{
|
|
return static_cast<double>(get_elapsed_cpu_time_microseconds()) * 1e-6;
|
|
}
|
|
|
|
uint64_t Timer::get_elapsed_cpu_time_microseconds() const
|
|
{
|
|
CPUTime e;
|
|
GetCPUTimeMicroSeconds(&e);
|
|
return (e.user_time - m_start_time.user_time) +
|
|
(e.sys_time - m_start_time.sys_time);
|
|
}
|
|
|
|
double Timer::get_elapsed_wall_time() const
|
|
{
|
|
return static_cast<double>(get_elapsed_wall_time_microseconds()) * 1e-6;
|
|
}
|
|
|
|
uint64_t Timer::get_elapsed_wall_time_microseconds() const
|
|
{
|
|
return GetTimeOfDayMicroSeconds() - m_wall;
|
|
}
|
|
|
|
void Timer::start(const char* msg)
|
|
{
|
|
// Print an optional message, something like "Starting timer t";
|
|
if (msg) TRACE_ERR( msg << std::endl);
|
|
if (m_is_running) return;
|
|
m_is_running = true;
|
|
m_wall = GetTimeOfDayMicroSeconds();
|
|
GetCPUTimeMicroSeconds(&m_start_time);
|
|
}
|
|
|
|
void Timer::restart(const char* msg)
|
|
{
|
|
if (msg) {
|
|
TRACE_ERR(msg << std::endl);
|
|
}
|
|
m_wall = GetTimeOfDayMicroSeconds();
|
|
GetCPUTimeMicroSeconds(&m_start_time);
|
|
}
|
|
|
|
void Timer::check(const char* msg)
|
|
{
|
|
// Print an optional message, something like "Checking timer t";
|
|
if (msg) TRACE_ERR( msg << " : ");
|
|
|
|
if (m_is_running) {
|
|
TRACE_ERR("[Wall " << get_elapsed_wall_time()
|
|
<< " CPU " << get_elapsed_cpu_time() << "] seconds.\n");
|
|
} else {
|
|
TRACE_ERR("WARNING: the timer is not running.\n");
|
|
}
|
|
}
|
|
|
|
std::string Timer::ToString() const
|
|
{
|
|
std::string res;
|
|
const double wall = get_elapsed_wall_time();
|
|
CPUTime e;
|
|
GetCPUTimeMicroSeconds(&e);
|
|
const double utime = (e.user_time - m_start_time.user_time) * 1e-6;
|
|
const double stime = (e.sys_time - m_start_time.sys_time) * 1e-6;
|
|
std::stringstream ss;
|
|
ss << "wall " << wall << " sec. user " << utime << " sec. sys " << stime
|
|
<< " sec. total " << utime + stime << " sec.";
|
|
res.append(ss.str());
|
|
|
|
return res;
|
|
}
|
|
|
|
}
|