Switch to nanoseconds and use <chrono>

Author: darbitman

src/config.h.cmake.in

@@ -195,6 +195,9 @@
 /* Check whether C++11 atomic is available */
 #cmakedefine HAVE_CXX11_ATOMIC ${HAVE_CXX11_ATOMIC}
 
+/* Check whether C++11 chrono is available */
+#cmakedefine HAVE_CXX11_CHRONO ${HAVE_CXX11_CHRONO}
+
 /* Check whether C++11 nullptr_t is available */
 #cmakedefine HAVE_CXX11_NULLPTR_T ${HAVE_CXX11_NULLPTR_T}
 

src/logging_unittest.cc

@@ -1002,18 +1002,17 @@ namespace LogTimes {
 // between total running time of 100ms and the period of 10ms. The period is
 // large enough such that any CPU and OS scheduling variation shouldn't affect
 // the results from the ideal case by more than 5% (500us or 0.5ms)
-GLOG_CONSTEXPR double LOG_PERIOD_SEC = 0.01;
-GLOG_CONSTEXPR int64_t LOG_PERIOD_US     = 10000;
-GLOG_CONSTEXPR int64_t LOG_PERIOD_TOL_US = 500;
+GLOG_CONSTEXPR int64_t LOG_PERIOD_NS     = 10000000;  // 10ms
+GLOG_CONSTEXPR int64_t LOG_PERIOD_TOL_NS = 500000;    // 500us
 
 // Set an upper limit for the number of times the stream operator can be
 // called. Make sure not to exceed this number of times the stream operator is
 // called, since it is also the array size and will be indexed by the stream
 // operator.
-GLOG_CONSTEXPR size_t MAX_CALLS          = 10;
+GLOG_CONSTEXPR size_t MAX_CALLS = 10;
 }  // namespace LogStreamTimes
 
-#if HAVE_CXX11_CHRONO
+#ifdef HAVE_CXX11_CHRONO
 struct LogTimeRecorder {
   size_t m_streamTimes = 0;
   std::chrono::steady_clock::time_point m_callTimes[LogTimes::MAX_CALLS];
@@ -1025,10 +1024,10 @@ std::ostream& operator<<(std::ostream& stream, LogTimeRecorder& t) {
   t.m_callTimes[t.m_streamTimes++] = std::chrono::steady_clock::now();
   return stream;
 }
-// get elapsed time in microseconds
-int64 elapsedTime_us(const std::chrono::steady_clock::time_point& begin,
+// get elapsed time in nanoseconds
+int64 elapsedTime_ns(const std::chrono::steady_clock::time_point& begin,
         const std::chrono::steady_clock::time_point& end) {
-  return std::chrono::duration_cast<std::chrono::microseconds>((end - begin))
+  return std::chrono::duration_cast<std::chrono::nanoseconds>((end - begin))
           .count();
 }
 #elif defined(OS_WINDOWS)
@@ -1040,11 +1039,11 @@ std::ostream& operator<<(std::ostream& stream, LogTimeRecorder& t) {
   QueryPerformanceCounter(&t.m_callTimes[t.m_streamTimes++]);
   return stream;
 }
-// get elapsed time in micrseconds
-int64 elapsedTime_us(const LARGE_INTEGER& begin, const LARGE_INTEGER& end) {
+// get elapsed time in nanoseconds
+int64 elapsedTime_ns(const LARGE_INTEGER& begin, const LARGE_INTEGER& end) {
   LARGE_INTEGER freq;
   QueryPerformanceFrequency(&freq);
-  return (end.QuadPart - begin.QuadPart) * 1000000 / freq.QuadPart;
+  return (end.QuadPart - begin.QuadPart) * 1000000000 / freq.QuadPart;
 }
 #else
 struct LogTimeRecorder {
@@ -1055,11 +1054,10 @@ std::ostream& operator<<(std::ostream& stream, LogTimeRecorder& t) {
   clock_gettime(CLOCK_MONOTONIC, &t.m_callTimes[t.m_streamTimes++]);
   return stream;
 }
-// get elapsed time in microseconds
-int64 elapsedTime_us(const timespec& begin, const timespec& end) {
-  const int64 elapsed_ns = ((end.tv_sec - begin.tv_sec) * 1000000000) +
-                           (end.tv_nsec - begin.tv_nsec);
-  return elapsed_ns / 1000;
+// get elapsed time in nanoseconds
+int64 elapsedTime_ns(const timespec& begin, const timespec& end) {
+  return (end.tv_sec - begin.tv_sec) * 1000000000 +
+         (end.tv_nsec - begin.tv_nsec);
 }
 #endif
 
@@ -1068,22 +1066,24 @@ static void TestLogPeriodically() {
 
   LogTimeRecorder timeLogger;
 
+  GLOG_CONSTEXPR double LOG_PERIOD_SEC = LogTimes::LOG_PERIOD_NS / 1000000000.0;
+
   while (timeLogger.m_streamTimes < LogTimes::MAX_CALLS) {
-    LOG_EVERY_T(INFO, LogTimes::LOG_PERIOD_SEC)
+        LOG_EVERY_T(INFO, LOG_PERIOD_SEC)
             << timeLogger << "Timed Message #" << timeLogger.m_streamTimes;
   }
 
-  // Calculate time between each call in microseconds for higher resolution to
+  // Calculate time between each call in nanoseconds for higher resolution to
   // minimize error.
-  int64 usBetweenCalls[LogTimes::MAX_CALLS - 1];
+  int64 nsBetweenCalls[LogTimes::MAX_CALLS - 1];
   for (size_t i = 1; i < LogTimes::MAX_CALLS; ++i) {
-    usBetweenCalls[i - 1] = elapsedTime_us(
+    nsBetweenCalls[i - 1] = elapsedTime_ns(
             timeLogger.m_callTimes[i - 1], timeLogger.m_callTimes[i]);
   }
 
   for (size_t idx = 0; idx < LogTimes::MAX_CALLS - 1; ++idx) {
-    int64 time = usBetweenCalls[idx];
-    EXPECT_NEAR(time, LogTimes::LOG_PERIOD_US, LogTimes::LOG_PERIOD_TOL_US);
+    int64 time_ns = nsBetweenCalls[idx];
+    EXPECT_NEAR(time_ns, LogTimes::LOG_PERIOD_NS, LogTimes::LOG_PERIOD_TOL_NS);
   }
 }