Timer->UsageTimer consistently

test/cpp/qps/client.h

@@ -112,12 +112,12 @@ class ClientRequestCreator<ByteBuffer> {
 
 class Client {
  public:
-  Client() : timer_(new Timer), interarrival_timer_() {}
+  Client() : timer_(new UsageTimer), interarrival_timer_() {}
   virtual ~Client() {}
 
   ClientStats Mark(bool reset) {
     Histogram latencies;
-    Timer::Result timer_result;
+    UsageTimer::Result timer_result;
 
     // avoid std::vector for old compilers that expect a copy constructor
     if (reset) {
@@ -125,7 +125,7 @@ class Client {
       for (size_t i = 0; i < threads_.size(); i++) {
         threads_[i]->BeginSwap(&to_merge[i]);
       }
-      std::unique_ptr<Timer> timer(new Timer);
+      std::unique_ptr<UsageTimer> timer(new UsageTimer);
       timer_.swap(timer);
       for (size_t i = 0; i < threads_.size(); i++) {
         threads_[i]->EndSwap();
@@ -294,7 +294,7 @@ class Client {
   };
 
   std::vector<std::unique_ptr<Thread>> threads_;
-  std::unique_ptr<Timer> timer_;
+  std::unique_ptr<UsageTimer> timer_;
 
   InterarrivalTimer interarrival_timer_;
   std::vector<gpr_timespec> next_time_;

test/cpp/qps/client_async.cc

@@ -107,14 +107,14 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
   bool RunNextState(bool ok, Histogram* hist) GRPC_OVERRIDE {
     switch (next_state_) {
       case State::READY:
-        start_ = Timer::Now();
+        start_ = UsageTimer::Now();
         response_reader_ = start_req_(stub_, &context_, req_, cq_);
         response_reader_->Finish(&response_, &status_,
                                  ClientRpcContext::tag(this));
         next_state_ = State::RESP_DONE;
         return true;
       case State::RESP_DONE:
-        hist->Add((Timer::Now() - start_) * 1e9);
+        hist->Add((UsageTimer::Now() - start_) * 1e9);
         callback_(status_, &response_);
         next_state_ = State::INVALID;
         return false;
@@ -287,8 +287,7 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
         next_state_(State::INVALID),
         callback_(on_done),
         next_issue_(next_issue),
-        start_req_(start_req),
-        start_(Timer::Now()) {}
+        start_req_(start_req) {}
   ~ClientRpcContextStreamingImpl() GRPC_OVERRIDE {}
   void Start(CompletionQueue* cq) GRPC_OVERRIDE {
     cq_ = cq;
@@ -314,7 +313,7 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
           if (!ok) {
             return false;
           }
-          start_ = Timer::Now();
+          start_ = UsageTimer::Now();
           next_state_ = State::WRITE_DONE;
           stream_->Write(req_, ClientRpcContext::tag(this));
           return true;
@@ -327,7 +326,7 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
           return true;
           break;
         case State::READ_DONE:
-          hist->Add((Timer::Now() - start_) * 1e9);
+          hist->Add((UsageTimer::Now() - start_) * 1e9);
           callback_(status_, &response_);
           next_state_ = State::STREAM_IDLE;
           break;  // loop around
@@ -415,8 +414,7 @@ class ClientRpcContextGenericStreamingImpl : public ClientRpcContext {
         next_state_(State::INVALID),
         callback_(on_done),
         next_issue_(next_issue),
-        start_req_(start_req),
-        start_(Timer::Now()) {}
+        start_req_(start_req) {}
   ~ClientRpcContextGenericStreamingImpl() GRPC_OVERRIDE {}
   void Start(CompletionQueue* cq) GRPC_OVERRIDE {
     cq_ = cq;
@@ -445,7 +443,7 @@ class ClientRpcContextGenericStreamingImpl : public ClientRpcContext {
           if (!ok) {
             return false;
           }
-          start_ = Timer::Now();
+          start_ = UsageTimer::Now();
           next_state_ = State::WRITE_DONE;
           stream_->Write(req_, ClientRpcContext::tag(this));
           return true;
@@ -458,7 +456,7 @@ class ClientRpcContextGenericStreamingImpl : public ClientRpcContext {
           return true;
           break;
         case State::READ_DONE:
-          hist->Add((Timer::Now() - start_) * 1e9);
+          hist->Add((UsageTimer::Now() - start_) * 1e9);
           callback_(status_, &response_);
           next_state_ = State::STREAM_IDLE;
           break;  // loop around

test/cpp/qps/client_sync.cc

@@ -104,12 +104,12 @@ class SynchronousUnaryClient GRPC_FINAL : public SynchronousClient {
   bool ThreadFunc(Histogram* histogram, size_t thread_idx) GRPC_OVERRIDE {
     WaitToIssue(thread_idx);
     auto* stub = channels_[thread_idx % channels_.size()].get_stub();
-    double start = Timer::Now();
+    double start = UsageTimer::Now();
     GPR_TIMER_SCOPE("SynchronousUnaryClient::ThreadFunc", 0);
     grpc::ClientContext context;
     grpc::Status s =
         stub->UnaryCall(&context, request_, &responses_[thread_idx]);
-    histogram->Add((Timer::Now() - start) * 1e9);
+    histogram->Add((UsageTimer::Now() - start) * 1e9);
     return s.ok();
   }
 };
@@ -143,10 +143,10 @@ class SynchronousStreamingClient GRPC_FINAL : public SynchronousClient {
   bool ThreadFunc(Histogram* histogram, size_t thread_idx) GRPC_OVERRIDE {
     WaitToIssue(thread_idx);
     GPR_TIMER_SCOPE("SynchronousStreamingClient::ThreadFunc", 0);
-    double start = Timer::Now();
+    double start = UsageTimer::Now();
     if (stream_[thread_idx]->Write(request_) &&
         stream_[thread_idx]->Read(&responses_[thread_idx])) {
-      histogram->Add((Timer::Now() - start) * 1e9);
+      histogram->Add((UsageTimer::Now() - start) * 1e9);
       return true;
     }
     return false;

test/cpp/qps/server.h

@@ -50,7 +50,7 @@ namespace testing {
 
 class Server {
  public:
-  explicit Server(const ServerConfig& config) : timer_(new Timer) {
+  explicit Server(const ServerConfig& config) : timer_(new UsageTimer) {
     cores_ = LimitCores(config.core_list().data(), config.core_list_size());
     if (config.port()) {
       port_ = config.port();
@@ -62,9 +62,9 @@ class Server {
   virtual ~Server() {}
 
   ServerStats Mark(bool reset) {
-    Timer::Result timer_result;
+    UsageTimer::Result timer_result;
     if (reset) {
-      std::unique_ptr<Timer> timer(new Timer);
+      std::unique_ptr<UsageTimer> timer(new UsageTimer);
       timer.swap(timer_);
       timer_result = timer->Mark();
     } else {
@@ -108,7 +108,7 @@ class Server {
  private:
   int port_;
   int cores_;
-  std::unique_ptr<Timer> timer_;
+  std::unique_ptr<UsageTimer> timer_;
 };
 
 std::unique_ptr<Server> CreateSynchronousServer(const ServerConfig& config);

test/cpp/qps/usage_timer.cc

@@ -37,9 +37,9 @@
 #include <sys/resource.h>
 #include <sys/time.h>
 
-Timer::Timer() : start_(Sample()) {}
+UsageTimer::UsageTimer() : start_(Sample()) {}
 
-double Timer::Now() {
+double UsageTimer::Now() {
   auto ts = gpr_now(GPR_CLOCK_REALTIME);
   return ts.tv_sec + 1e-9 * ts.tv_nsec;
 }
@@ -48,7 +48,7 @@ static double time_double(struct timeval* tv) {
   return tv->tv_sec + 1e-6 * tv->tv_usec;
 }
 
-Timer::Result Timer::Sample() {
+UsageTimer::Result UsageTimer::Sample() {
   struct rusage usage;
   struct timeval tv;
   gettimeofday(&tv, NULL);
@@ -61,7 +61,7 @@ Timer::Result Timer::Sample() {
   return r;
 }
 
-Timer::Result Timer::Mark() const {
+UsageTimer::Result UsageTimer::Mark() const {
   Result s = Sample();
   Result r;
   r.wall = s.wall - start_.wall;

test/cpp/qps/usage_timer.h

@@ -36,7 +36,7 @@
 
 class UsageTimer {
  public:
-  Timer();
+  UsageTimer();
 
   struct Result {
     double wall;