116 lines
2.9 KiB
C++
116 lines
2.9 KiB
C++
#include "osdrvutil.hpp"
|
|
|
|
#if defined(__linux__)
|
|
#include <time.h>
|
|
#elif defined(_WIN32)
|
|
#include <windows.h>
|
|
#include <profileapi.h>
|
|
#else
|
|
#error "Only support __linux__ or _WIN32"
|
|
#endif
|
|
|
|
#include <string>
|
|
#include <cstring>
|
|
#include <cassert>
|
|
#include <cstdio>
|
|
|
|
// strerror has to be the most overcomplicated function imaginable. The simple
|
|
// version, 'strerror', is not thread-safe, and the improved versions are all
|
|
// incompatible from OS to OS. Even different versions of linux aren't
|
|
// compatible. A lot of conditional compilation is needed.
|
|
|
|
#if defined(__linux__)
|
|
|
|
inline static void strerror_helper(int status, int errnum, char errbuf[256]) {
|
|
if (status != 0) {
|
|
snprintf(errbuf, 256, "unknown errno %d", errnum);
|
|
}
|
|
}
|
|
|
|
inline static void strerror_helper(const char *result, int errnum, char errbuf[256]) {
|
|
if (result != errbuf) {
|
|
snprintf(errbuf, 256, "%s", result);
|
|
}
|
|
}
|
|
|
|
static void strerror_safe(int errnum, char errbuf[256]) {
|
|
auto rval = strerror_r(errnum, errbuf, 256);
|
|
strerror_helper(rval, errnum, errbuf);
|
|
}
|
|
|
|
#elif defined(_WIN32)
|
|
|
|
static void strerror_safe(int errnum, char errbuf[256]) {
|
|
int status = strerror_s(errbuf, 256, errnum);
|
|
if (status != 0) {
|
|
snprintf(errbuf, 256, "unknown errno %d", errnum);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
// The monotonic clock is required to start at zero at initialization time,
|
|
// advance steadily, and never go backwards. It is okay, however, if it is a
|
|
// little inaccurate, or if it drifts a little over time.
|
|
|
|
#if defined(__linux__)
|
|
|
|
class MonoClock {
|
|
private:
|
|
struct timespec base_;
|
|
public:
|
|
MonoClock() {
|
|
int status = clock_gettime(CLOCK_MONOTONIC, &base_);
|
|
assert(status == 0);
|
|
}
|
|
double get() {
|
|
struct timespec t;
|
|
int status = clock_gettime(CLOCK_MONOTONIC, &t);
|
|
assert(status == 0);
|
|
double tv_sec = t.tv_sec - base_.tv_sec;
|
|
double tv_nsec = t.tv_nsec - base_.tv_nsec;
|
|
return tv_sec + (tv_nsec * 1.0E-9);
|
|
}
|
|
};
|
|
|
|
#elif defined(_WIN32)
|
|
|
|
class MonoClock {
|
|
public:
|
|
double freq_;
|
|
LONGLONG base_;
|
|
inline LONGLONG qpc() {
|
|
LARGE_INTEGER x;
|
|
BOOL status = QueryPerformanceCounter(&x);
|
|
assert(status != 0);
|
|
return x.QuadPart;
|
|
}
|
|
MonoClock() {
|
|
LARGE_INTEGER x;
|
|
BOOL status = QueryPerformanceFrequency(&x);
|
|
assert(status != 0);
|
|
freq_ = 1.0 / double(x.QuadPart);
|
|
base_ = qpc();
|
|
}
|
|
double get() {
|
|
return (qpc() - base_) * freq_;
|
|
}
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
namespace drvutil {
|
|
|
|
static MonoClock monoclock;
|
|
double get_monotonic_clock() {
|
|
return monoclock.get();
|
|
}
|
|
|
|
std::string strerror_str(int errnum) {
|
|
char buf[256];
|
|
strerror_safe(errnum, buf);
|
|
return buf;
|
|
|
|
}
|
|
} // namespace drvutil
|