diff --git a/example/auto_concurrency_limiter/client.cpp b/example/auto_concurrency_limiter/client.cpp
index d33325ddf9..af293af9ad 100644
--- a/example/auto_concurrency_limiter/client.cpp
+++ b/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;
diff --git a/example/auto_concurrency_limiter/server.cpp b/example/auto_concurrency_limiter/server.cpp
index 61f826fab7..a161b188ed 100644
--- a/example/auto_concurrency_limiter/server.cpp
+++ b/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();
diff --git a/example/dynamic_partition_echo_c++/server.cpp b/example/dynamic_partition_echo_c++/server.cpp
index e86affaa91..eda57b4243 100644
--- a/example/dynamic_partition_echo_c++/server.cpp
+++ b/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);
             }
diff --git a/example/multi_threaded_echo_fns_c++/server.cpp b/example/multi_threaded_echo_fns_c++/server.cpp
index 2e837bbf46..a25ef96e81 100644
--- a/example/multi_threaded_echo_fns_c++/server.cpp
+++ b/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);
             }
diff --git a/example/partition_echo_c++/server.cpp b/example/partition_echo_c++/server.cpp
index aa65d41b7a..7dbcf8f519 100644
--- a/example/partition_echo_c++/server.cpp
+++ b/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);
             }
diff --git a/example/rdma_performance/client.cpp b/example/rdma_performance/client.cpp
index a7ed2c99c6..2e8acc4051 100644
--- a/example/rdma_performance/client.cpp
+++ b/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)
diff --git a/example/selective_echo_c++/server.cpp b/example/selective_echo_c++/server.cpp
index 0705a32890..d1ed8bb940 100644
--- a/example/selective_echo_c++/server.cpp
+++ b/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);
             }
diff --git a/src/brpc/cluster_recover_policy.cpp b/src/brpc/cluster_recover_policy.cpp
index d1338f6609..bb59a23c0f 100644
--- a/src/brpc/cluster_recover_policy.cpp
+++ b/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);
diff --git a/src/brpc/details/health_check.cpp b/src/brpc/details/health_check.cpp
index cfd49104d6..7cf4e32bcf 100644
--- a/src/brpc/details/health_check.cpp
+++ b/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,
diff --git a/src/brpc/global.cpp b/src/brpc/global.cpp
index 1f67aee20b..90f19cd5bc 100644
--- a/src/brpc/global.cpp
+++ b/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();
 
diff --git a/src/brpc/policy/auto_concurrency_limiter.cpp b/src/brpc/policy/auto_concurrency_limiter.cpp
index 51ea56d765..e9cce0fa43 100644
--- a/src/brpc/policy/auto_concurrency_limiter.cpp
+++ b/src/brpc/policy/auto_concurrency_limiter.cpp
@@ -87,7 +87,7 @@ DEFINE_double(auto_cl_error_rate_punish_threshold, 0,
 
 AutoConcurrencyLimiter::AutoConcurrencyLimiter()
     : _max_concurrency(FLAGS_auto_cl_initial_max_concurrency)
-    , _remeasure_start_us(NextResetTime(butil::gettimeofday_us()))
+    , _remeasure_start_us(NextResetTime(butil::cpuwide_time_us()))
     , _reset_latency_us(0)
     , _min_latency_us(-1)
     , _ema_max_qps(-1)
@@ -111,7 +111,7 @@ void AutoConcurrencyLimiter::OnResponded(int error_code, int64_t latency_us) {
         return;
     }
 
-    const int64_t now_time_us = butil::gettimeofday_us();
+    const int64_t now_time_us = butil::cpuwide_time_us();
     int64_t last_sampling_time_us = 
         _last_sampling_time_us.load(butil::memory_order_relaxed);
 
diff --git a/src/brpc/policy/locality_aware_load_balancer.cpp b/src/brpc/policy/locality_aware_load_balancer.cpp
index beea51690e..455f6fc397 100644
--- a/src/brpc/policy/locality_aware_load_balancer.cpp
+++ b/src/brpc/policy/locality_aware_load_balancer.cpp
@@ -18,7 +18,7 @@
 
 #include <limits>                                            // numeric_limits
 #include <gflags/gflags.h>
-#include "butil/time.h"                                       // gettimeofday_us
+#include "butil/time.h"                                      // cpuwide_time_us
 #include "butil/fast_rand.h"
 #include "brpc/log.h"
 #include "brpc/socket.h"
@@ -376,7 +376,7 @@ void LocalityAwareLoadBalancer::Feedback(const CallInfo& info) {
 
 int64_t LocalityAwareLoadBalancer::Weight::Update(
     const CallInfo& ci, size_t index) {
-    const int64_t end_time_us = butil::gettimeofday_us();
+    const int64_t end_time_us = butil::cpuwide_time_us();
     const int64_t latency = end_time_us - ci.begin_time_us;
     BAIDU_SCOPED_LOCK(_mutex);
     if (Disabled()) {
@@ -524,7 +524,7 @@ void LocalityAwareLoadBalancer::Describe(
     if (_db_servers.Read(&s) != 0) {
         os << "fail to read _db_servers";
     } else {
-        const int64_t now = butil::gettimeofday_us();
+        const int64_t now = butil::cpuwide_time_us();
         const size_t n = s->weight_tree.size();
         os << '[';
         for (size_t i = 0; i < n; ++i) {
diff --git a/src/brpc/policy/timeout_concurrency_limiter.cpp b/src/brpc/policy/timeout_concurrency_limiter.cpp
index b2582eb12b..21aad33fc1 100644
--- a/src/brpc/policy/timeout_concurrency_limiter.cpp
+++ b/src/brpc/policy/timeout_concurrency_limiter.cpp
@@ -91,7 +91,7 @@ void TimeoutConcurrencyLimiter::OnResponded(int error_code,
         return;
     }
 
-    const int64_t now_time_us = butil::gettimeofday_us();
+    const int64_t now_time_us = butil::cpuwide_time_us();
     int64_t last_sampling_time_us =
         _last_sampling_time_us.load(butil::memory_order_relaxed);
 
diff --git a/src/brpc/server.cpp b/src/brpc/server.cpp
index 9470220d09..3a5da7b771 100644
--- a/src/brpc/server.cpp
+++ b/src/brpc/server.cpp
@@ -372,10 +372,10 @@ void* Server::UpdateDerivedVars(void* arg) {
     }
 #endif
 
-    int64_t last_time = butil::gettimeofday_us();
+    int64_t last_time = butil::cpuwide_time_us();
     int consecutive_nosleep = 0;
     while (1) {
-        const int64_t sleep_us = 1000000L + last_time - butil::gettimeofday_us();
+        const int64_t sleep_us = 1000000L + last_time - butil::cpuwide_time_us();
         if (sleep_us < 1000L) {
             if (++consecutive_nosleep >= 2) {
                 consecutive_nosleep = 0;
@@ -388,7 +388,7 @@ void* Server::UpdateDerivedVars(void* arg) {
                 return NULL;
             }
         }
-        last_time = butil::gettimeofday_us();
+        last_time = butil::cpuwide_time_us();
 
         // Update stats of accepted sockets.
         if (server->_am) {
diff --git a/src/brpc/socket.cpp b/src/brpc/socket.cpp
index da926c9ff5..78bd4e23d2 100644
--- a/src/brpc/socket.cpp
+++ b/src/brpc/socket.cpp
@@ -572,7 +572,7 @@ int Socket::ResetFileDescriptor(int fd) {
     // MUST store `_fd' before adding itself into epoll device to avoid
     // race conditions with the callback function inside epoll
     _fd.store(fd, butil::memory_order_release);
-    _reset_fd_real_us = butil::gettimeofday_us();
+    _reset_fd_real_us = butil::cpuwide_time_us();
     if (!ValidFileDescriptor(fd)) {
         return 0;
     }
@@ -2316,7 +2316,7 @@ void Socket::DebugSocket(std::ostream& os, SocketId id) {
        << "\nnevent=" << ptr->_nevent.load(butil::memory_order_relaxed)
        << "\nfd=" << fd
        << "\ntos=" << ptr->_tos
-       << "\nreset_fd_to_now=" << butil::gettimeofday_us() - ptr->_reset_fd_real_us << "us"
+       << "\nreset_fd_to_now=" << butil::cpuwide_time_us() - ptr->_reset_fd_real_us << "us"
        << "\nremote_side=" << ptr->_remote_side
        << "\nlocal_side=" << ptr->_local_side
        << "\non_et_events=" << (void*)ptr->_on_edge_triggered_events
diff --git a/src/brpc/trackme.cpp b/src/brpc/trackme.cpp
index 85598a68a0..4decc35269 100644
--- a/src/brpc/trackme.cpp
+++ b/src/brpc/trackme.cpp
@@ -225,7 +225,7 @@ void TrackMe() {
     if (FLAGS_trackme_server.empty()) {
         return;
     }
-    int64_t now = butil::gettimeofday_us();
+    int64_t now = butil::cpuwide_time_us();
     std::unique_lock<pthread_mutex_t> mu(s_trackme_mutex);
     if (s_trackme_last_time == 0) {
         // Delay the first ping randomly within s_trackme_interval. This
diff --git a/src/bvar/collector.cpp b/src/bvar/collector.cpp
index a01f45fdbc..c4adf634b7 100644
--- a/src/bvar/collector.cpp
+++ b/src/bvar/collector.cpp
@@ -305,8 +305,8 @@ void Collector::update_speed_limit(CollectorSpeedLimit* sl,
     size_t new_sampling_range = 0;
     const size_t old_sampling_range = sl->sampling_range;
     if (!sl->ever_grabbed) {
-        if (sl->first_sample_real_us) {
-            interval_us = butil::gettimeofday_us() - sl->first_sample_real_us;
+        if (sl->first_sample_us) {
+            interval_us = butil::cpuwide_time_us() - sl->first_sample_us;
             if (interval_us < 0) {
                 interval_us = 0;
             }
@@ -350,7 +350,7 @@ size_t is_collectable_before_first_time_grabbed(CollectorSpeedLimit* sl) {
         int before_add = sl->count_before_grabbed.fetch_add(
             1, butil::memory_order_relaxed);
         if (before_add == 0) {
-            sl->first_sample_real_us = butil::gettimeofday_us();
+            sl->first_sample_us = butil::cpuwide_time_us();
         } else if (before_add >= FLAGS_bvar_collector_expected_per_second) {
             butil::get_leaky_singleton<Collector>()->wakeup_grab_thread();
         }
diff --git a/src/bvar/collector.h b/src/bvar/collector.h
index a603d96b34..473d4ac7ab 100644
--- a/src/bvar/collector.h
+++ b/src/bvar/collector.h
@@ -40,7 +40,7 @@ struct CollectorSpeedLimit {
     size_t sampling_range;
     bool ever_grabbed;
     butil::static_atomic<int> count_before_grabbed;
-    int64_t first_sample_real_us;
+    int64_t first_sample_us;
 };
 
 static const size_t COLLECTOR_SAMPLING_BASE = 16384;
diff --git a/src/bvar/default_variables.cpp b/src/bvar/default_variables.cpp
index a84c3ab08b..1d60063526 100644
--- a/src/bvar/default_variables.cpp
+++ b/src/bvar/default_variables.cpp
@@ -144,7 +144,7 @@ class CachedReader {
     template <typename ReadFn>
     static const T& get_value(const ReadFn& fn) {
         CachedReader* p = butil::get_leaky_singleton<CachedReader>();
-        const int64_t now = butil::gettimeofday_us();
+        const int64_t now = butil::cpuwide_time_us();
         if (now > p->_mtime_us + CACHED_INTERVAL_US) {
             pthread_mutex_lock(&p->_mutex);
             if (now > p->_mtime_us + CACHED_INTERVAL_US) {
@@ -625,10 +625,10 @@ static void get_kernel_version(std::ostream& os, void*) {
 
 // ======================================
 
-static int64_t g_starting_time = butil::gettimeofday_us();
+static int64_t g_starting_time = butil::cpuwide_time_us();
 
 static timeval get_uptime(void*) {
-    int64_t uptime_us = butil::gettimeofday_us() - g_starting_time;
+    int64_t uptime_us = butil::cpuwide_time_us() - g_starting_time;
     timeval tm;
     tm.tv_sec = uptime_us / 1000000L;
     tm.tv_usec = uptime_us - tm.tv_sec * 1000000L;
diff --git a/src/bvar/detail/sampler.cpp b/src/bvar/detail/sampler.cpp
index dd6271e7ba..f3462558c1 100644
--- a/src/bvar/detail/sampler.cpp
+++ b/src/bvar/detail/sampler.cpp
@@ -155,7 +155,7 @@ void SamplerCollector::run() {
     butil::LinkNode<Sampler> root;
     int consecutive_nosleep = 0;
     while (!_stop) {
-        int64_t abstime = butil::gettimeofday_us();
+        int64_t abstime = butil::cpuwide_time_ns();
         Sampler* s = this->reset();
         if (s) {
             s->InsertBeforeAsList(&root);
@@ -176,13 +176,13 @@ void SamplerCollector::run() {
             p = saved_next;
         }
         bool slept = false;
-        int64_t now = butil::gettimeofday_us();
+        int64_t now = butil::cpuwide_time_ns();
         _cumulated_time_us += now - abstime;
         abstime += 1000000L;
         while (abstime > now) {
             ::usleep(abstime - now);
             slept = true;
-            now = butil::gettimeofday_us();
+            now = butil::cpuwide_time_ns();
         }
         if (slept) {
             consecutive_nosleep = 0;
diff --git a/src/bvar/detail/sampler.h b/src/bvar/detail/sampler.h
index 85ec237453..32b976dcbd 100644
--- a/src/bvar/detail/sampler.h
+++ b/src/bvar/detail/sampler.h
@@ -26,7 +26,7 @@
 #include "butil/logging.h"               // LOG()
 #include "butil/containers/bounded_queue.h"// BoundedQueue
 #include "butil/type_traits.h"           // is_same
-#include "butil/time.h"                  // gettimeofday_us
+#include "butil/time.h"                  // cpuwide_time_us
 #include "butil/class_name.h"
 
 namespace bvar {
@@ -136,7 +136,7 @@ class ReducerSampler : public Sampler {
             // get_value() of _reducer can still be called.
             latest.data = _reducer->get_value();
         }
-        latest.time_us = butil::gettimeofday_us();
+        latest.time_us = butil::cpuwide_time_us();
         _q.elim_push(latest);
     }
 
diff --git a/test/brpc_auto_concurrency_limiter_unittest.cpp b/test/brpc_auto_concurrency_limiter_unittest.cpp
index 77163e2fb8..ac572b82a8 100644
--- a/test/brpc_auto_concurrency_limiter_unittest.cpp
+++ b/test/brpc_auto_concurrency_limiter_unittest.cpp
@@ -78,7 +78,7 @@ void AddSamplesAndTriggerWindow(brpc::policy::AutoConcurrencyLimiter& limiter,
                                  int succ_count, int64_t succ_latency,
                                  int fail_count, int64_t fail_latency) {
     ASSERT_GT(succ_count, 0) << "Need at least 1 success to trigger window";
-    int64_t now = butil::gettimeofday_us();
+    int64_t now = butil::cpuwide_time_us();
 
     // Add successful samples (reserve one for the trigger)
     for (int i = 0; i < succ_count - 1; ++i) {
diff --git a/test/brpc_channel_unittest.cpp b/test/brpc_channel_unittest.cpp
index de33b44393..2004767470 100644
--- a/test/brpc_channel_unittest.cpp
+++ b/test/brpc_channel_unittest.cpp
@@ -495,9 +495,9 @@ class ChannelTest : public ::testing::Test{
         EXPECT_EQ("received " + std::string(__FUNCTION__), res.message());
         if (short_connection) {
             // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-            const int64_t start_time = butil::gettimeofday_us();
+            const int64_t start_time = butil::cpuwide_time_us();
             while (_messenger.ConnectionCount() != 0) {
-                EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+                EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
                 bthread_usleep(1000);
             }
         } else {
@@ -655,9 +655,9 @@ class ChannelTest : public ::testing::Test{
         }
         if (short_connection) {
             // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-            const int64_t start_time = butil::gettimeofday_us();
+            const int64_t start_time = butil::cpuwide_time_us();
             while (_messenger.ConnectionCount() != 0) {
-                EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+                EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
                 bthread_usleep(1000);
             }
         } else {
@@ -707,9 +707,9 @@ class ChannelTest : public ::testing::Test{
         }
         if (short_connection) {
             // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-            const int64_t start_time = butil::gettimeofday_us();
+            const int64_t start_time = butil::cpuwide_time_us();
             while (_messenger.ConnectionCount() != 0) {
-                EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+                EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
                 bthread_usleep(1000);
             }
         } else {
@@ -751,9 +751,9 @@ class ChannelTest : public ::testing::Test{
         
         if (short_connection) {
             // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-            const int64_t start_time = butil::gettimeofday_us();
+            const int64_t start_time = butil::cpuwide_time_us();
             while (_messenger.ConnectionCount() != 0) {
-                EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+                EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
                 bthread_usleep(1000);
             }
         } else {
@@ -800,9 +800,9 @@ class ChannelTest : public ::testing::Test{
         }
         if (short_connection) {
             // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-            const int64_t start_time = butil::gettimeofday_us();
+            const int64_t start_time = butil::cpuwide_time_us();
             while (_messenger.ConnectionCount() != 0) {
-                EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+                EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
                 bthread_usleep(1000);
             }
         } else {
@@ -861,9 +861,9 @@ class ChannelTest : public ::testing::Test{
         }
         if (short_connection) {
             // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-            const int64_t start_time = butil::gettimeofday_us();
+            const int64_t start_time = butil::cpuwide_time_us();
             while (_messenger.ConnectionCount() != 0) {
-                EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+                EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
                 bthread_usleep(1000);
             }
         } else {
@@ -914,9 +914,9 @@ class ChannelTest : public ::testing::Test{
         ASSERT_EQ((int)1, res.code_list(0));
         if (short_connection) {
             // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-            const int64_t start_time = butil::gettimeofday_us();
+            const int64_t start_time = butil::cpuwide_time_us();
             while (_messenger.ConnectionCount() != 0) {
-                EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+                EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
                 bthread_usleep(1000);
             }
         } else {
@@ -1215,9 +1215,9 @@ class ChannelTest : public ::testing::Test{
         EXPECT_EQ("received " + std::string(__FUNCTION__), res.message());
         if (short_connection) {
             // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-            const int64_t start_time = butil::gettimeofday_us();
+            const int64_t start_time = butil::cpuwide_time_us();
             while (_messenger.ConnectionCount() != 0) {
-                EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+                EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
                 bthread_usleep(1000);
             }
         } else {
@@ -1672,9 +1672,9 @@ class ChannelTest : public ::testing::Test{
         EXPECT_EQ(0, cntl.ErrorCode()) << cntl.ErrorText();
         EXPECT_EQ("received " + std::string(__FUNCTION__), res.message());
         // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-        const int64_t start_time = butil::gettimeofday_us();
+        const int64_t start_time = butil::cpuwide_time_us();
         while (_messenger.ConnectionCount() != 0) {
-            EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+            EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
             bthread_usleep(1000);
         }
 
@@ -1705,9 +1705,9 @@ class ChannelTest : public ::testing::Test{
         EXPECT_EQ(0, cntl.ErrorCode()) << cntl.ErrorText();
         EXPECT_EQ("received " + std::string(__FUNCTION__), res.message());
         // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-        const int64_t start_time = butil::gettimeofday_us();
+        const int64_t start_time = butil::cpuwide_time_us();
         while (_messenger.ConnectionCount() != 0) {
-            EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+            EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
             bthread_usleep(1000);
         }
         StopAndJoin();
@@ -1741,9 +1741,9 @@ class ChannelTest : public ::testing::Test{
         ASSERT_EQ(0, cntl.sub(0)->ErrorCode());
 
         // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-        const int64_t start_time = butil::gettimeofday_us();
+        const int64_t start_time = butil::cpuwide_time_us();
         while (_messenger.ConnectionCount() != 0) {
-            EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+            EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
             bthread_usleep(1000);
         }
         StopAndJoin();
@@ -1938,9 +1938,9 @@ class ChannelTest : public ::testing::Test{
             EXPECT_EQ(0, cntl.ErrorCode()) << cntl.ErrorText();
             EXPECT_EQ(1, cntl.retried_count());
 
-            const int64_t start_time = butil::gettimeofday_us();
+            const int64_t start_time = butil::cpuwide_time_us();
             while (_messenger.ConnectionCount() != 0) {
-                EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+                EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
                 bthread_usleep(1000);
             }
         } else {
@@ -2096,9 +2096,9 @@ class ChannelTest : public ::testing::Test{
 
         if (short_connection) {
             // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-            const int64_t start_time = butil::gettimeofday_us();
+            const int64_t start_time = butil::cpuwide_time_us();
             while (_messenger.ConnectionCount() != 0) {
-                EXPECT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+                EXPECT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
                 bthread_usleep(1000);
             }
         } else {
@@ -2156,9 +2156,9 @@ class ChannelTest : public ::testing::Test{
 
             if (short_connection) {
                 // Sleep to let `_messenger' detect `Socket' being `SetFailed'
-                const int64_t start_time = butil::gettimeofday_us();
+                const int64_t start_time = butil::cpuwide_time_us();
                 while (_messenger.ConnectionCount() != 0) {
-                    ASSERT_LT(butil::gettimeofday_us(), start_time + 100000L/*100ms*/);
+                    ASSERT_LT(butil::cpuwide_time_us(), start_time + 100000L/*100ms*/);
                     bthread_usleep(1000);
                 }
             } else {
diff --git a/test/brpc_h2_unsent_message_unittest.cpp b/test/brpc_h2_unsent_message_unittest.cpp
index acb79039ff..5e3b266dfe 100644
--- a/test/brpc_h2_unsent_message_unittest.cpp
+++ b/test/brpc_h2_unsent_message_unittest.cpp
@@ -57,12 +57,12 @@ TEST(H2UnsentMessage, request_throughput) {
     // calc H2UnsentRequest throughput
     butil::IOBuf dummy_buf;
     ProfilerStart("h2_unsent_req.prof");
-    int64_t start_us = butil::gettimeofday_us();
+    int64_t start_us = butil::cpuwide_time_us();
     for (int i = 0; i < ntotal; ++i) {
         brpc::policy::H2UnsentRequest* req = brpc::policy::H2UnsentRequest::New(&cntl);
         req->AppendAndDestroySelf(&dummy_buf, h2_client_sock.get());
     }
-    int64_t end_us = butil::gettimeofday_us();
+    int64_t end_us = butil::cpuwide_time_us();
     ProfilerStop();
     int64_t elapsed = end_us - start_us;
     LOG(INFO) << "H2UnsentRequest average qps="
@@ -71,7 +71,7 @@ TEST(H2UnsentMessage, request_throughput) {
 
     // calc H2UnsentResponse throughput
     dummy_buf.clear();
-    start_us = butil::gettimeofday_us();
+    start_us = butil::cpuwide_time_us();
     for (int i = 0; i < ntotal; ++i) {
         // H2UnsentResponse::New would release cntl.http_response() and swap
         // cntl.response_attachment()
@@ -80,7 +80,7 @@ TEST(H2UnsentMessage, request_throughput) {
         brpc::policy::H2UnsentResponse* res = brpc::policy::H2UnsentResponse::New(&cntl, 0, false);
         res->AppendAndDestroySelf(&dummy_buf, h2_client_sock.get());
     }
-    end_us = butil::gettimeofday_us();
+    end_us = butil::cpuwide_time_us();
     elapsed = end_us - start_us;
     LOG(INFO) << "H2UnsentResponse average qps="
         << (ntotal * 1000000L) / elapsed << "/s, data throughput="
diff --git a/test/brpc_http_rpc_protocol_unittest.cpp b/test/brpc_http_rpc_protocol_unittest.cpp
index f13c6877f7..b75a6da3a4 100644
--- a/test/brpc_http_rpc_protocol_unittest.cpp
+++ b/test/brpc_http_rpc_protocol_unittest.cpp
@@ -2008,14 +2008,14 @@ void ReadOneResponse(brpc::SocketUniquePtr& sock,
 #endif
 
     butil::IOPortal read_buf;
-    int64_t start_time = butil::gettimeofday_us();
+    int64_t start_time = butil::cpuwide_time_us();
     while (true) {
         const ssize_t nr = read_buf.append_from_file_descriptor(sock->fd(), 4096);
         LOG(INFO) << "nr=" << nr;
         LOG(INFO) << butil::ToPrintableString(read_buf);
         ASSERT_TRUE(nr > 0 || (nr < 0 && errno == EAGAIN));
         if (errno == EAGAIN) {
-            ASSERT_LT(butil::gettimeofday_us(), start_time + 1000000L) << "Too long!";
+            ASSERT_LT(butil::cpuwide_time_us(), start_time + 1000000L) << "Too long!";
             bthread_usleep(1000);
             continue;
         }
@@ -2059,10 +2059,10 @@ TEST_F(HttpTest, http_expect) {
     request_buf.append(content);
 
     ASSERT_EQ(0, sock->Write(&header_buf));
-    int64_t start_time = butil::gettimeofday_us();
+    int64_t start_time = butil::cpuwide_time_us();
     while (sock->fd() < 0) {
         bthread_usleep(1000);
-        ASSERT_LT(butil::gettimeofday_us(), start_time + 1000000L) << "Too long!";
+        ASSERT_LT(butil::cpuwide_time_us(), start_time + 1000000L) << "Too long!";
     }
     // 100 Continue
     brpc::DestroyingPtr<brpc::policy::HttpContext> imsg_guard;
diff --git a/test/brpc_load_balancer_unittest.cpp b/test/brpc_load_balancer_unittest.cpp
index 07059484d7..2a2be242aa 100644
--- a/test/brpc_load_balancer_unittest.cpp
+++ b/test/brpc_load_balancer_unittest.cpp
@@ -174,8 +174,8 @@ void DBDMultiBthread() {
     }
 
     // Modify during reading.
-    int64_t start = butil::gettimeofday_ms();
-    while (butil::gettimeofday_ms() - start < 10 * 1000) {
+    int64_t start = butil::cpuwide_time_ms();
+    while (butil::cpuwide_time_ms() - start < 10 * 1000) {
         d.Modify(AddN, 1);
         typename DBD::ScopedPtr ptr;
         d.Read(&ptr);
@@ -277,9 +277,9 @@ void PerfTest(int thread_num, bool modify_during_reading) {
     ProfilerStart(prof_name);
     int64_t run_ms = 5 * 1000;
     if (modify_during_reading) {
-        int64_t start = butil::gettimeofday_ms();
+        int64_t start = butil::cpuwide_time_ms();
         int i = 1;
-        while (butil::gettimeofday_ms() - start < run_ms) {
+        while (butil::cpuwide_time_ms() - start < run_ms) {
             ASSERT_TRUE(dbd.Modify(AddMapN, i++));
             usleep(1000);
         }
@@ -1276,8 +1276,8 @@ TEST_F(LoadBalancerTest, revived_from_all_failed_intergrated) {
     ASSERT_EQ(0, server2.AddService(&service2, brpc::SERVER_DOESNT_OWN_SERVICE));
     ASSERT_EQ(0, server2.Start(point2, NULL));
     
-    int64_t start_ms = butil::gettimeofday_ms();
-    while ((butil::gettimeofday_ms() - start_ms) < 3500) {
+    int64_t start_ms = butil::cpuwide_time_ms();
+    while ((butil::cpuwide_time_ms() - start_ms) < 3500) {
         Done* done = new Done;
         done->req.set_message("123");
         stub.Echo(&done->cntl, &done->req, &done->res, done);
diff --git a/test/brpc_socket_unittest.cpp b/test/brpc_socket_unittest.cpp
index 8e9f90e833..9851287411 100644
--- a/test/brpc_socket_unittest.cpp
+++ b/test/brpc_socket_unittest.cpp
@@ -37,7 +37,6 @@
 #include "brpc/policy/hulu_pbrpc_protocol.h"
 #include "brpc/policy/most_common_message.h"
 #include "brpc/policy/http_rpc_protocol.h"
-#include "brpc/nshead.h"
 #include "brpc/server.h"
 #include "brpc/channel.h"
 #include "brpc/controller.h"
@@ -399,10 +398,10 @@ TEST_F(SocketTest, single_threaded_connect_and_write) {
                 my_connect->MakeConnectDone();
                 ASSERT_LT(0, called); // serialized
             }
-            int64_t start_time = butil::gettimeofday_us();
+            int64_t start_time = butil::cpuwide_time_us();
             while (s->fd() < 0) {
                 bthread_usleep(1000);
-                ASSERT_LT(butil::gettimeofday_us(), start_time + 1000000L) << "Too long!";
+                ASSERT_LT(butil::cpuwide_time_us(), start_time + 1000000L) << "Too long!";
             }
 #if defined(OS_LINUX)
             ASSERT_EQ(0, bthread_fd_wait(s->fd(), EPOLLIN));
@@ -502,10 +501,10 @@ TEST_F(SocketTest, fail_to_connect) {
         ASSERT_EQ(-1, s->fd());
     }
     // KeepWrite is possibly still running.
-    int64_t start_time = butil::gettimeofday_us();
+    int64_t start_time = butil::cpuwide_time_us();
     while (global_sock != NULL) {
         bthread_usleep(1000);
-        ASSERT_LT(butil::gettimeofday_us(), start_time + 1000000L) << "Too long!";
+        ASSERT_LT(butil::cpuwide_time_us(), start_time + 1000000L) << "Too long!";
     }
     ASSERT_EQ(-1, brpc::Socket::Status(id));
     // The id is invalid.
@@ -567,10 +566,10 @@ TEST_F(SocketTest, not_health_check_when_nref_hits_0) {
     // is NULL(set in CheckRecycle::BeforeRecycle). Notice that you should
     // not spin until Socket::Status(id) becomes -1 and assert global_sock
     // to be NULL because invalidating id happens before calling BeforeRecycle.
-    const int64_t start_time = butil::gettimeofday_us();
+    const int64_t start_time = butil::cpuwide_time_us();
     while (global_sock != NULL) {
         bthread_usleep(1000);
-        ASSERT_LT(butil::gettimeofday_us(), start_time + 1000000L);
+        ASSERT_LT(butil::cpuwide_time_us(), start_time + 1000000L);
     }
     ASSERT_EQ(-1, brpc::Socket::Status(id));
 }
@@ -751,11 +750,11 @@ TEST_F(SocketTest, health_check) {
     ASSERT_EQ(0, messenger->AddHandler(pairs[0]));
     ASSERT_EQ(0, messenger->StartAccept(listening_fd, -1, NULL, false));
 
-    int64_t start_time = butil::gettimeofday_us();
+    int64_t start_time = butil::cpuwide_time_us();
     nref = -1;
     while (brpc::Socket::Status(id, &nref) != 0) {
         bthread_usleep(1000);
-        ASSERT_LT(butil::gettimeofday_us(),
+        ASSERT_LT(butil::cpuwide_time_us(),
                   start_time + kCheckInteval * 1000000L + 100000L/*100ms*/);
     }
     //ASSERT_EQ(2, nref);
@@ -772,10 +771,10 @@ TEST_F(SocketTest, health_check) {
     // SetFailed again, should reconnect and succeed soon.
     ASSERT_EQ(0, s->SetFailed());
     ASSERT_EQ(fd, s->fd());
-    start_time = butil::gettimeofday_us();
+    start_time = butil::cpuwide_time_us();
     while (brpc::Socket::Status(id) != 0) {
         bthread_usleep(1000);
-        ASSERT_LT(butil::gettimeofday_us(), start_time + 1200000L);
+        ASSERT_LT(butil::cpuwide_time_us(), start_time + 1200000L);
     }
     ASSERT_TRUE(global_sock);
 
@@ -797,10 +796,10 @@ TEST_F(SocketTest, health_check) {
 
     ASSERT_EQ(0, brpc::Socket::SetFailed(id));
     // StartHealthCheck is possibly still addressing the Socket.
-    start_time = butil::gettimeofday_us();
+    start_time = butil::cpuwide_time_us();
     while (global_sock != NULL) {
         bthread_usleep(1000);
-        ASSERT_LT(butil::gettimeofday_us(), start_time + 1000000L);
+        ASSERT_LT(butil::cpuwide_time_us(), start_time + 1000000L);
     }
     nref = 0;
     ASSERT_EQ(-1, brpc::Socket::Status(id, &nref)) << "nref=" << nref;
@@ -879,7 +878,7 @@ TEST_F(SocketTest, multi_threaded_write) {
         }
         
         butil::IOPortal dest;
-        const int64_t start_time = butil::gettimeofday_us();
+        const int64_t start_time = butil::cpuwide_time_us();
         for (;;) {
             ssize_t nr = dest.append_from_file_descriptor(fds[0], 32768);
             if (nr < 0) {
@@ -890,7 +889,7 @@ TEST_F(SocketTest, multi_threaded_write) {
                     ASSERT_EQ(EAGAIN, errno) << berror();
                 }
                 bthread_usleep(1000);
-                if (butil::gettimeofday_us() >= start_time + 2000000L) {
+                if (butil::cpuwide_time_us() >= start_time + 2000000L) {
                     LOG(FATAL) << "Wait too long!";
                     break;
                 }
diff --git a/test/brpc_timeout_concurrency_limiter_unittest.cpp b/test/brpc_timeout_concurrency_limiter_unittest.cpp
index 11b9e23bf0..a8e11ecd1b 100644
--- a/test/brpc_timeout_concurrency_limiter_unittest.cpp
+++ b/test/brpc_timeout_concurrency_limiter_unittest.cpp
@@ -35,56 +35,56 @@ TEST(TimeoutConcurrencyLimiterTest, AddSample) {
         brpc::policy::FLAGS_timeout_cl_max_sample_count = 10;
 
         brpc::policy::TimeoutConcurrencyLimiter limiter;
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
         bthread_usleep(10 * 1000);
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
         ASSERT_EQ(limiter._sw.succ_count, 0);
         ASSERT_EQ(limiter._sw.failed_count, 0);
 
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
         bthread_usleep(10 * 1000);
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
         ASSERT_EQ(limiter._sw.succ_count, 0);
         ASSERT_EQ(limiter._sw.failed_count, 0);
         ASSERT_EQ(limiter._avg_latency_us, 50);
 
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
         ASSERT_EQ(limiter._sw.succ_count, 0);
         ASSERT_EQ(limiter._sw.failed_count, 0);
         ASSERT_EQ(limiter._avg_latency_us, 50);
 
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
         ASSERT_EQ(limiter._sw.succ_count, 6);
         ASSERT_EQ(limiter._sw.failed_count, 0);
 
-        limiter.ResetSampleWindow(butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(0, 50, butil::gettimeofday_us());
-        limiter.AddSample(1, 50, butil::gettimeofday_us());
-        limiter.AddSample(1, 50, butil::gettimeofday_us());
-        limiter.AddSample(1, 50, butil::gettimeofday_us());
+        limiter.ResetSampleWindow(butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(0, 50, butil::cpuwide_time_us());
+        limiter.AddSample(1, 50, butil::cpuwide_time_us());
+        limiter.AddSample(1, 50, butil::cpuwide_time_us());
+        limiter.AddSample(1, 50, butil::cpuwide_time_us());
         ASSERT_EQ(limiter._sw.succ_count, 3);
         ASSERT_EQ(limiter._sw.failed_count, 3);
     }
diff --git a/test/bvar_recorder_unittest.cpp b/test/bvar_recorder_unittest.cpp
index c0d3206244..7493c34541 100644
--- a/test/bvar_recorder_unittest.cpp
+++ b/test/bvar_recorder_unittest.cpp
@@ -96,10 +96,10 @@ TEST(RecorderTest, window) {
     bvar::Window<bvar::IntRecorder> w3(&c1, 3);
 
     const int N = 10000;
-    int64_t last_time = butil::gettimeofday_us();
+    int64_t last_time = butil::cpuwide_time_us();
     for (int i = 1; i <= N; ++i) {
         c1 << i;
-        int64_t now = butil::gettimeofday_us();
+        int64_t now = butil::cpuwide_time_us();
         if (now - last_time >= 1000000L) {
             last_time = now;
             LOG(INFO) << "c1=" << c1 << " w1=" << w1 << " w2=" << w2 << " w3=" << w3;
@@ -244,15 +244,15 @@ TEST(RecorderTest, latency_recorder_qps_accuracy) {
         double err = fabs(qps_sum / 1000.0 - exp_qps);
         return err;
     };
-    ASSERT_GT(0.1, read(lr1, 10/2.0));
-    ASSERT_GT(0.1, read(lr2, 11/2.0));
-    ASSERT_GT(0.1, read(lr3, 3/2.0));
-    ASSERT_GT(0.1, read(lr4, 1/2.0));
+    ASSERT_GT(0.2, read(lr1, 10/2.0));
+    ASSERT_GT(0.2, read(lr2, 11/2.0));
+    ASSERT_GT(0.2, read(lr3, 3/2.0));
+    ASSERT_GT(0.2, read(lr4, 1/2.0));
 
-    ASSERT_GT(0.1, read(lr1, 10/3.0, 3));
+    ASSERT_GT(0.2, read(lr1, 10/3.0, 3));
     ASSERT_GT(0.2, read(lr2, 11/3.0, 3));
-    ASSERT_GT(0.1, read(lr3, 3/3.0, 3));
-    ASSERT_GT(0.1, read(lr4, 1/3.0, 3));
+    ASSERT_GT(0.2, read(lr3, 3/3.0, 3));
+    ASSERT_GT(0.2, read(lr4, 1/3.0, 3));
 }
 
 } // namespace
diff --git a/test/bvar_reducer_unittest.cpp b/test/bvar_reducer_unittest.cpp
index 48e13b3c0b..5bd3477ce5 100644
--- a/test/bvar_reducer_unittest.cpp
+++ b/test/bvar_reducer_unittest.cpp
@@ -218,14 +218,14 @@ void ReducerTest_window() {
     const int N = 6000;
     int count = 0;
     int total_count = 0;
-    int64_t last_time = butil::gettimeofday_us();
+    int64_t last_time = butil::cpuwide_time_us();
     for (int i = 1; i <= N; ++i) {
         c1 << 1;
         c2 << N - i;
         c3 << i;
         ++count;
         ++total_count;
-        int64_t now = butil::gettimeofday_us();
+        int64_t now = butil::cpuwide_time_us();
         if (now - last_time >= 1000000L) {
             last_time = now;
             ASSERT_EQ(total_count, c1.get_value());
diff --git a/tools/rpc_press/info_thread.cpp b/tools/rpc_press/info_thread.cpp
index 99c9db1cae..fc3d8f87bb 100644
--- a/tools/rpc_press/info_thread.cpp
+++ b/tools/rpc_press/info_thread.cpp
@@ -36,18 +36,18 @@ void InfoThread::run() {
     int64_t last_sent_count = 0;
     int64_t last_succ_count = 0;
     int64_t last_error_count = 0;
-    int64_t start_time = butil::gettimeofday_us();
+    int64_t start_time = butil::cpuwide_time_us();
     while (!_stop) {
         int64_t end_time = 0;
         while (!_stop &&
-               (end_time = butil::gettimeofday_us()) < start_time + 1000000L) {
+               (end_time = butil::cpuwide_time_us()) < start_time + 1000000L) {
             BAIDU_SCOPED_LOCK(_mutex);
             if (!_stop) {
                 timespec ts = butil::microseconds_to_timespec(end_time);
                 pthread_cond_timedwait(&_cond, &_mutex, &ts);
             }
         }
-        start_time = butil::gettimeofday_us();
+        start_time = butil::cpuwide_time_us();
         char buf[64];
         const time_t tm_s = start_time / 1000000L;
         struct tm lt;
diff --git a/tools/rpc_press/rpc_press_impl.cpp b/tools/rpc_press/rpc_press_impl.cpp
index 07c8dbcfac..8da10c1495 100644
--- a/tools/rpc_press/rpc_press_impl.cpp
+++ b/tools/rpc_press/rpc_press_impl.cpp
@@ -195,7 +195,7 @@ void RpcPress::handle_response(brpc::Controller* cntl,
                                Message* response, 
                                int64_t start_time){
     if (!cntl->Failed()){
-        int64_t rpc_call_time_us = butil::gettimeofday_us() - start_time;
+        int64_t rpc_call_time_us = butil::cpuwide_time_us() - start_time;
         _latency_recorder << rpc_call_time_us;
 
         if (_output_json) {
@@ -235,7 +235,7 @@ void RpcPress::sync_client() {
         msg_index = (msg_index + _options.test_thread_num) % _msgs.size();
         Message* request = _msgs[msg_index];
         Message* response = _pbrpc_client->get_output_message();
-        const int64_t start_time = butil::gettimeofday_us();
+        const int64_t start_time = butil::cpuwide_time_us();
         google::protobuf::Closure* done = brpc::NewCallback<
             RpcPress, 
             RpcPress*, 
diff --git a/tools/rpc_replay/info_thread.cpp b/tools/rpc_replay/info_thread.cpp
index d20d70e874..f31e597141 100644
--- a/tools/rpc_replay/info_thread.cpp
+++ b/tools/rpc_replay/info_thread.cpp
@@ -36,18 +36,18 @@ void InfoThread::run() {
     int64_t last_sent_count = 0;
     int64_t last_succ_count = 0;
     int64_t last_error_count = 0;
-    int64_t start_time = butil::gettimeofday_us();
+    int64_t start_time = butil::cpuwide_time_us();
     while (!_stop) {
         int64_t end_time = 0;
         while (!_stop &&
-               (end_time = butil::gettimeofday_us()) < start_time + 1000000L) {
+               (end_time = butil::cpuwide_time_us()) < start_time + 1000000L) {
             BAIDU_SCOPED_LOCK(_mutex);
             if (!_stop) {
                 timespec ts = butil::microseconds_to_timespec(end_time);
                 pthread_cond_timedwait(&_cond, &_mutex, &ts);
             }
         }
-        start_time = butil::gettimeofday_us();
+        start_time = butil::cpuwide_time_us();
         char buf[64];
         const time_t tm_s = start_time / 1000000L;
         struct tm lt;
diff --git a/tools/rpc_replay/rpc_replay.cpp b/tools/rpc_replay/rpc_replay.cpp
index c3cd7c4c3a..395da6b67e 100644
--- a/tools/rpc_replay/rpc_replay.cpp
+++ b/tools/rpc_replay/rpc_replay.cpp
@@ -119,7 +119,7 @@ static void handle_response(brpc::Controller* cntl, int64_t start_time,
     // TODO(gejun): some bthreads are starved when new bthreads are created 
     // continuously, which happens when server is down and RPC keeps failing.
     // Sleep a while on error to avoid that now.
-    const int64_t end_time = butil::gettimeofday_us();
+    const int64_t end_time = butil::cpuwide_time_us();
     const int64_t elp = end_time - start_time;
     if (!cntl->Failed()) {
         g_latency_recorder << elp;
@@ -190,7 +190,7 @@ static void* replay_thread(void* arg) {
                 req.serialized_data() = sample->request.movable();
             }
             g_sent_count << 1;
-            const int64_t start_time = butil::gettimeofday_us();
+            const int64_t start_time = butil::cpuwide_time_us();
             if (FLAGS_qps <= 0) {
                 chan->CallMethod(NULL/*use rpc_dump_context in cntl instead*/,
                         cntl, req_ptr, NULL/*ignore response*/, NULL);