Move Monoclock and strerror out of drvutil

luprex/cpp/drv/osdrvutil.cpp

@@ -0,0 +1,116 @@
+#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