Use monotonic time instead of wall time

Author: chenBright

example/auto_concurrency_limiter/client.cpp

@@ -119,13 +119,13 @@ struct TestCaseContext {
         , stage_index(0)
         , test_case(tc)
         , next_stage_sec(test_case.qps_stage_list(0).duration_sec() + 
-                         butil::gettimeofday_s()) {
+                         butil::cpuwide_time_s()) {
         DisplayStage(test_case.qps_stage_list(stage_index));
         Update();
     }
 
     bool Update() {
-        if (butil::gettimeofday_s() >= next_stage_sec) {
+        if (butil::cpuwide_time_s() >= next_stage_sec) {
             ++stage_index;
             if (stage_index < test_case.qps_stage_list_size()) {
                 next_stage_sec += test_case.qps_stage_list(stage_index).duration_sec(); 
@@ -144,7 +144,7 @@ struct TestCaseContext {
         } else if (qps_stage.type() == test::SMOOTH) {
             qps = lower_bound + (upper_bound - lower_bound) / 
                 double(qps_stage.duration_sec()) * (qps_stage.duration_sec() - next_stage_sec
-                + butil::gettimeofday_s());
+                + butil::cpuwide_time_s());
         }
         interval_us.store(1.0 / qps * 1000000, butil::memory_order_relaxed);
         return true;

example/auto_concurrency_limiter/server.cpp

@@ -96,7 +96,7 @@ class EchoServiceImpl : public test::EchoService {
     void SetTestCase(const test::TestCase& test_case) {
         _test_case = test_case;
         _next_stage_start = _test_case.latency_stage_list(0).duration_sec() + 
-            butil::gettimeofday_s();
+            butil::cpuwide_time_s();
         _stage_index = 0;
         _running_case = false;
         DisplayStage(_test_case.latency_stage_list(_stage_index));
@@ -137,7 +137,7 @@ class EchoServiceImpl : public test::EchoService {
 
     void ComputeLatency() {
         if (_stage_index < _test_case.latency_stage_list_size() &&
-            butil::gettimeofday_s() > _next_stage_start) {
+            butil::cpuwide_time_s() > _next_stage_start) {
             ++_stage_index;
             if (_stage_index < _test_case.latency_stage_list_size()) {
                 _next_stage_start += _test_case.latency_stage_list(_stage_index).duration_sec();
@@ -167,7 +167,7 @@ class EchoServiceImpl : public test::EchoService {
             int latency = lower_bound + (upper_bound - lower_bound) / 
                 double(latency_stage.duration_sec()) * 
                 (latency_stage.duration_sec() - _next_stage_start + 
-                butil::gettimeofday_s());
+                butil::cpuwide_time_s());
             _latency.store(latency, butil::memory_order_relaxed);
         } else {
             LOG(FATAL) << "Wrong Type:" << latency_stage.type();

example/dynamic_partition_echo_c++/server.cpp

@@ -69,8 +69,8 @@ class EchoServiceImpl : public example::EchoService {
                 }
             }
             if (FLAGS_spin) {
-                int64_t end_time = butil::gettimeofday_us() + (int64_t)delay;
-                while (butil::gettimeofday_us() < end_time) {}
+                int64_t end_time = butil::cpuwide_time_us() + (int64_t)delay;
+                while (butil::cpuwide_time_us() < end_time) {}
             } else {
                 bthread_usleep((int64_t)delay);
             }

example/multi_threaded_echo_fns_c++/server.cpp

@@ -70,8 +70,8 @@ class EchoServiceImpl : public example::EchoService {
                 }
             }
             if (FLAGS_spin) {
-                int64_t end_time = butil::gettimeofday_us() + (int64_t)delay;
-                while (butil::gettimeofday_us() < end_time) {}
+                int64_t end_time = butil::cpuwide_time_us() + (int64_t)delay;
+                while (butil::cpuwide_time_us() < end_time) {}
             } else {
                 bthread_usleep((int64_t)delay);
             }

example/partition_echo_c++/server.cpp

@@ -69,8 +69,8 @@ class EchoServiceImpl : public example::EchoService {
                 }
             }
             if (FLAGS_spin) {
-                int64_t end_time = butil::gettimeofday_us() + (int64_t)delay;
-                while (butil::gettimeofday_us() < end_time) {}
+                int64_t end_time = butil::cpuwide_time_us() + (int64_t)delay;
+                while (butil::cpuwide_time_us() < end_time) {}
             } else {
                 bthread_usleep((int64_t)delay);
             }

example/rdma_performance/client.cpp

@@ -176,7 +176,7 @@ class PerformanceTest {
         }
         --closure->test->_iterations;
         uint64_t last = g_last_time.load(butil::memory_order_relaxed);
-        uint64_t now = butil::gettimeofday_us();
+        uint64_t now = butil::cpuwide_time_us();
         if (now > last && now - last > 100000) {
             if (g_last_time.exchange(now, butil::memory_order_relaxed) == last) {
                 g_client_cpu_recorder << 
@@ -192,7 +192,7 @@ class PerformanceTest {
 
     static void* RunTest(void* arg) {
         PerformanceTest* test = (PerformanceTest*)arg;
-        test->_start_time = butil::gettimeofday_us();
+        test->_start_time = butil::cpuwide_time_us();
         test->_iterations = FLAGS_test_iterations;
 
         for (int i = 0; i < FLAGS_queue_depth; ++i) {
@@ -235,7 +235,7 @@ void Test(int thread_num, int attachment_size) {
         }
         tests.push_back(t);
     }
-    uint64_t start_time = butil::gettimeofday_us();
+    uint64_t start_time = butil::cpuwide_time_us();
     bthread_t tid[thread_num];
     if (FLAGS_expected_qps > 0) {
         bthread_t tid;
@@ -250,7 +250,7 @@ void Test(int thread_num, int attachment_size) {
             bthread_usleep(10000);
         }
     }
-    uint64_t end_time = butil::gettimeofday_us();
+    uint64_t end_time = butil::cpuwide_time_us();
     double throughput = g_total_bytes / 1.048576 / (end_time - start_time);
     if (FLAGS_test_iterations == 0) {
         std::cout << "Avg-Latency: " << g_latency_recorder.latency(10)

example/selective_echo_c++/server.cpp

@@ -68,8 +68,8 @@ class EchoServiceImpl : public example::EchoService {
                 }
             }
             if (FLAGS_spin) {
-                int64_t end_time = butil::gettimeofday_us() + (int64_t)delay;
-                while (butil::gettimeofday_us() < end_time) {}
+                int64_t end_time = butil::cpuwide_time_us() + (int64_t)delay;
+                while (butil::cpuwide_time_us() < end_time) {}
             } else {
                 bthread_usleep((int64_t)delay);
             }

src/brpc/cluster_recover_policy.cpp

@@ -51,7 +51,7 @@ bool DefaultClusterRecoverPolicy::StopRecoverIfNecessary() {
     if (!_recovering) {
         return false;
     }
-    int64_t now_ms = butil::gettimeofday_ms();
+    int64_t now_ms = butil::cpuwide_time_ms();
     std::unique_lock<butil::Mutex> mu(_mutex);
     if (_last_usable_change_time_ms != 0 && _last_usable != 0 &&
             (now_ms - _last_usable_change_time_ms > _hold_seconds * 1000)) {
@@ -92,7 +92,7 @@ bool DefaultClusterRecoverPolicy::DoReject(const std::vector<ServerId>& server_l
     if (!_recovering) {
         return false;
     }
-    int64_t now_ms = butil::gettimeofday_ms();
+    int64_t now_ms = butil::cpuwide_time_ms();
     uint64_t usable = GetUsableServerCount(now_ms, server_list);
     if (_last_usable != usable) {
         std::unique_lock<butil::Mutex> mu(_mutex);

src/brpc/details/health_check.cpp

@@ -99,7 +99,7 @@ void* HealthCheckManager::AppCheck(void* arg) {
     done->cntl.Reset();
     done->cntl.http_request().uri() = done->hc_option.health_check_path;
     ControllerPrivateAccessor(&done->cntl).set_health_check_call();
-    done->last_check_time_ms = butil::gettimeofday_ms();
+    done->last_check_time_ms = butil::cpuwide_time_ms();
     done->channel.CallMethod(NULL, &done->cntl, NULL, NULL, done);
     return NULL;
 }
@@ -126,7 +126,7 @@ void OnAppHealthCheckDone::Run() {
         << ", " << cntl.ErrorText();
 
     int64_t sleep_time_ms =
-        last_check_time_ms + interval_s * 1000 - butil::gettimeofday_ms();
+        last_check_time_ms + interval_s * 1000 - butil::cpuwide_time_ms();
     if (sleep_time_ms > 0) {
         // TODO(zhujiashun): we need to handle the case when timer fails
         // and bthread_usleep returns immediately. In most situations,

src/brpc/global.cpp

@@ -238,13 +238,13 @@ static void* GlobalUpdate(void*) {
     }
 
     std::vector<SocketId> conns;
-    const int64_t start_time_us = butil::gettimeofday_us();
+    const int64_t start_time_us = butil::cpuwide_time_us();
     const int WARN_NOSLEEP_THRESHOLD = 2;
     int64_t last_time_us = start_time_us;
     int consecutive_nosleep = 0;
     int64_t last_return_free_memory_time = start_time_us;
     while (1) {
-        const int64_t sleep_us = 1000000L + last_time_us - butil::gettimeofday_us();
+        const int64_t sleep_us = 1000000L + last_time_us - butil::cpuwide_time_us();
         if (sleep_us > 0) {
             if (bthread_usleep(sleep_us) < 0) {
                 PLOG_IF(FATAL, errno != ESTOP) << "Fail to sleep";
@@ -257,7 +257,7 @@ static void* GlobalUpdate(void*) {
                 LOG(WARNING) << __FUNCTION__ << " is too busy!";
             }
         }
-        last_time_us = butil::gettimeofday_us();
+        last_time_us = butil::cpuwide_time_us();
 
         TrackMe();