clang-format

include/grpc++/config.h

@@ -99,24 +99,28 @@
   ::google::protobuf::io::ZeroCopyOutputStream
 #define GRPC_CUSTOM_ZEROCOPYINPUTSTREAM \
   ::google::protobuf::io::ZeroCopyInputStream
-#define GRPC_CUSTOM_CODEDINPUTSTREAM \
-  ::google::protobuf::io::CodedInputStream
+#define GRPC_CUSTOM_CODEDINPUTSTREAM ::google::protobuf::io::CodedInputStream
 #endif
 
-
 #ifdef GRPC_CXX0X_NO_NULLPTR
 #include <memory>
 const class {
-public:
-  template <class T> operator T*() const {return static_cast<T *>(0);}
-  template <class T> operator std::unique_ptr<T>() const {
+ public:
+  template <class T>
+  operator T *() const {
+    return static_cast<T *>(0);
+  }
+  template <class T>
+  operator std::unique_ptr<T>() const {
     return std::unique_ptr<T>(static_cast<T *>(0));
   }
-  template <class T> operator std::shared_ptr<T>() const {
+  template <class T>
+  operator std::shared_ptr<T>() const {
     return std::shared_ptr<T>(static_cast<T *>(0));
   }
-  operator bool() const {return false;}
-private:
+  operator bool() const { return false; }
+
+ private:
   void operator&() const = delete;
 } nullptr = {};
 #endif

include/grpc++/time.h

@@ -52,22 +52,22 @@ namespace grpc {
 template <typename T>
 class TimePoint {
  public:
-  TimePoint(const T& time) {
-    you_need_a_specialization_of_TimePoint();
-  }
+  TimePoint(const T& time) { you_need_a_specialization_of_TimePoint(); }
   gpr_timespec raw_time() {
     gpr_timespec t;
     return t;
   }
+
  private:
   void you_need_a_specialization_of_TimePoint();
 };
 
-template<>
+template <>
 class TimePoint<gpr_timespec> {
  public:
-  TimePoint(const gpr_timespec& time) : time_(time) { }
+  TimePoint(const gpr_timespec& time) : time_(time) {}
   gpr_timespec raw_time() { return time_; }
+
  private:
   gpr_timespec time_;
 };
@@ -85,8 +85,9 @@ namespace grpc {
 // from and to should be absolute time.
 void Timepoint2Timespec(const std::chrono::system_clock::time_point& from,
                         gpr_timespec* to);
-void TimepointHR2Timespec(const std::chrono::high_resolution_clock::time_point& from,
-                        gpr_timespec* to);
+void TimepointHR2Timespec(
+    const std::chrono::high_resolution_clock::time_point& from,
+    gpr_timespec* to);
 
 std::chrono::system_clock::time_point Timespec2Timepoint(gpr_timespec t);
 
@@ -94,9 +95,10 @@ template <>
 class TimePoint<std::chrono::system_clock::time_point> {
  public:
   TimePoint(const std::chrono::system_clock::time_point& time) {
-	Timepoint2Timespec(time, &time_);
+    Timepoint2Timespec(time, &time_);
   }
   gpr_timespec raw_time() const { return time_; }
+
  private:
   gpr_timespec time_;
 };

src/cpp/util/time.cc

@@ -61,7 +61,7 @@ void Timepoint2Timespec(const system_clock::time_point& from,
 }
 
 void TimepointHR2Timespec(const high_resolution_clock::time_point& from,
-			gpr_timespec* to) {
+                          gpr_timespec* to) {
   high_resolution_clock::duration deadline = from.time_since_epoch();
   seconds secs = duration_cast<seconds>(deadline);
   if (from == high_resolution_clock::time_point::max() ||

test/cpp/qps/client.h

@@ -50,9 +50,10 @@ template <>
 class TimePoint<std::chrono::high_resolution_clock::time_point> {
  public:
   TimePoint(const std::chrono::high_resolution_clock::time_point& time) {
-	TimepointHR2Timespec(time, &time_);
+    TimepointHR2Timespec(time, &time_);
   }
   gpr_timespec raw_time() const { return time_; }
+
  private:
   gpr_timespec time_;
 };
@@ -65,8 +66,8 @@ typedef std::chrono::time_point<grpc_time_source> grpc_time;
 
 class Client {
  public:
-  explicit Client(const ClientConfig& config) : timer_(new Timer),
-    interarrival_timer_() {
+  explicit Client(const ClientConfig& config)
+      : timer_(new Timer), interarrival_timer_() {
     for (int i = 0; i < config.client_channels(); i++) {
       channels_.push_back(ClientChannelInfo(
           config.server_targets(i % config.server_targets_size()), config));
@@ -131,30 +132,29 @@ class Client {
     // Set up the load distribution based on the number of threads
     if (config.load_type() == CLOSED_LOOP) {
       closed_loop_ = true;
-    }
-    else {
+    } else {
       closed_loop_ = false;
 
       std::unique_ptr<RandomDist> random_dist;
       auto& load = config.load_params();
       switch (config.load_type()) {
         case POISSON:
-          random_dist.reset
-              (new ExpDist(load.poisson().offered_load()/num_threads));
+          random_dist.reset(
+              new ExpDist(load.poisson().offered_load() / num_threads));
           break;
         case UNIFORM:
-          random_dist.reset
-              (new UniformDist(load.uniform().interarrival_lo()*num_threads,
-                               load.uniform().interarrival_hi()*num_threads));
+          random_dist.reset(
+              new UniformDist(load.uniform().interarrival_lo() * num_threads,
+                              load.uniform().interarrival_hi() * num_threads));
           break;
         case DETERMINISTIC:
-          random_dist.reset
-              (new DetDist(num_threads/load.determ().offered_load()));
+          random_dist.reset(
+              new DetDist(num_threads / load.determ().offered_load()));
           break;
         case PARETO:
-          random_dist.reset
-              (new ParetoDist(load.pareto().interarrival_base()*num_threads,
-                              load.pareto().alpha()));
+          random_dist.reset(
+              new ParetoDist(load.pareto().interarrival_base() * num_threads,
+                             load.pareto().alpha()));
           break;
         default:
           GPR_ASSERT(false);
@@ -162,23 +162,26 @@ class Client {
       }
 
       interarrival_timer_.init(*random_dist, num_threads);
-      for (size_t i = 0; i<num_threads; i++) {
-        next_time_.push_back(grpc_time_source::now() +
-			     std::chrono::duration_cast<grpc_time_source::duration>(interarrival_timer_(i)));
+      for (size_t i = 0; i < num_threads; i++) {
+        next_time_.push_back(
+            grpc_time_source::now() +
+            std::chrono::duration_cast<grpc_time_source::duration>(
+                interarrival_timer_(i)));
       }
     }
   }
-  bool NextIssueTime(int thread_idx, grpc_time *time_delay) {
+  bool NextIssueTime(int thread_idx, grpc_time* time_delay) {
     if (closed_loop_) {
       return false;
-    }
-    else {
+    } else {
       *time_delay = next_time_[thread_idx];
-      next_time_[thread_idx] += std::chrono::duration_cast<grpc_time_source::duration>(interarrival_timer_(thread_idx));
+      next_time_[thread_idx] +=
+          std::chrono::duration_cast<grpc_time_source::duration>(
+              interarrival_timer_(thread_idx));
       return true;
     }
   }
-  
+
  private:
   class Thread {
    public:

test/cpp/qps/client_async.cc

@@ -62,7 +62,7 @@ typedef std::list<grpc_time> deadline_list;
 
 class ClientRpcContext {
  public:
-  ClientRpcContext(int ch): channel_id_(ch) {}
+  ClientRpcContext(int ch) : channel_id_(ch) {}
   virtual ~ClientRpcContext() {}
   // next state, return false if done. Collect stats when appropriate
   virtual bool RunNextState(bool, Histogram* hist) = 0;
@@ -72,12 +72,16 @@ class ClientRpcContext {
     return reinterpret_cast<ClientRpcContext*>(t);
   }
 
-  deadline_list::iterator deadline_posn() const {return deadline_posn_;}
-  void set_deadline_posn(const deadline_list::iterator& it) {deadline_posn_ = it;}
-  virtual void Start(CompletionQueue *cq) = 0;
-  int channel_id() const {return channel_id_;}
+  deadline_list::iterator deadline_posn() const { return deadline_posn_; }
+  void set_deadline_posn(const deadline_list::iterator& it) {
+    deadline_posn_ = it;
+  }
+  virtual void Start(CompletionQueue* cq) = 0;
+  int channel_id() const { return channel_id_; }
+
  protected:
   int channel_id_;
+
  private:
   deadline_list::iterator deadline_posn_;
 };
@@ -85,23 +89,22 @@ class ClientRpcContext {
 template <class RequestType, class ResponseType>
 class ClientRpcContextUnaryImpl : public ClientRpcContext {
  public:
-  ClientRpcContextUnaryImpl(int channel_id,
-      TestService::Stub* stub, const RequestType& req,
+  ClientRpcContextUnaryImpl(
+      int channel_id, TestService::Stub* stub, const RequestType& req,
       std::function<
           std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>(
               TestService::Stub*, grpc::ClientContext*, const RequestType&,
-              CompletionQueue*)>
-          start_req,
+              CompletionQueue*)> start_req,
       std::function<void(grpc::Status, ResponseType*)> on_done)
-    : ClientRpcContext(channel_id), context_(),
+      : ClientRpcContext(channel_id),
+        context_(),
         stub_(stub),
         req_(req),
         response_(),
         next_state_(&ClientRpcContextUnaryImpl::RespDone),
         callback_(on_done),
-        start_req_(start_req) {
-  }
-  void Start(CompletionQueue *cq) GRPC_OVERRIDE {
+        start_req_(start_req) {}
+  void Start(CompletionQueue* cq) GRPC_OVERRIDE {
     start_ = Timer::Now();
     response_reader_ = start_req_(stub_, &context_, req_, cq);
     response_reader_->Finish(&response_, &status_, ClientRpcContext::tag(this));
@@ -116,8 +119,8 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
   }
 
   ClientRpcContext* StartNewClone() GRPC_OVERRIDE {
-    return new ClientRpcContextUnaryImpl(channel_id_,
-                                         stub_, req_, start_req_, callback_);
+    return new ClientRpcContextUnaryImpl(channel_id_, stub_, req_, start_req_,
+                                         callback_);
   }
 
  private:
@@ -125,9 +128,9 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
     next_state_ = &ClientRpcContextUnaryImpl::DoCallBack;
     return false;
   }
-  bool DoCallBack (bool) {
+  bool DoCallBack(bool) {
     callback_(status_, &response_);
-    return true; // we're done, this'll be ignored
+    return true;  // we're done, this'll be ignored
   }
   grpc::ClientContext context_;
   TestService::Stub* stub_;
@@ -136,27 +139,28 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
   bool (ClientRpcContextUnaryImpl::*next_state_)(bool);
   std::function<void(grpc::Status, ResponseType*)> callback_;
   std::function<std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>(
-      TestService::Stub*, grpc::ClientContext*,
-      const RequestType&, CompletionQueue *)> start_req_;
+      TestService::Stub*, grpc::ClientContext*, const RequestType&,
+      CompletionQueue*)> start_req_;
   grpc::Status status_;
   double start_;
   std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>
       response_reader_;
 };
 
-typedef std::forward_list<ClientRpcContext *> context_list;
+typedef std::forward_list<ClientRpcContext*> context_list;
 
 class AsyncClient : public Client {
  public:
-  explicit AsyncClient(const ClientConfig& config,
-		       std::function<ClientRpcContext*(int, TestService::Stub*,
-					  const SimpleRequest&)> setup_ctx) :
-      Client(config), channel_lock_(config.client_channels()),
-      contexts_(config.client_channels()),
-      max_outstanding_per_channel_(config.outstanding_rpcs_per_channel()),
-      channel_count_(config.client_channels()),
-      pref_channel_inc_(config.async_client_threads()) {
-
+  explicit AsyncClient(
+      const ClientConfig& config,
+      std::function<ClientRpcContext*(int, TestService::Stub*,
+                                      const SimpleRequest&)> setup_ctx)
+      : Client(config),
+        channel_lock_(config.client_channels()),
+        contexts_(config.client_channels()),
+        max_outstanding_per_channel_(config.outstanding_rpcs_per_channel()),
+        channel_count_(config.client_channels()),
+        pref_channel_inc_(config.async_client_threads()) {
     SetupLoadTest(config, config.async_client_threads());
 
     for (int i = 0; i < config.async_client_threads(); i++) {
@@ -181,8 +185,7 @@ class AsyncClient : public Client {
         auto ctx = setup_ctx(ch, channel.get_stub(), request_);
         if (closed_loop_) {
           ctx->Start(cq);
-        }
-        else {
+        } else {
           contexts_[ch].push_front(ctx);
         }
       }
@@ -210,24 +213,24 @@ class AsyncClient : public Client {
     } else {
       if (rpc_deadlines_[thread_idx].empty()) {
         deadline = grpc_time_source::now() + std::chrono::seconds(1);
-      }
-      else {
+      } else {
         deadline = *(rpc_deadlines_[thread_idx].begin());
       }
-      short_deadline = issue_allowed_[thread_idx] ?
-	next_issue_[thread_idx] : deadline;
+      short_deadline =
+          issue_allowed_[thread_idx] ? next_issue_[thread_idx] : deadline;
     }
 
     bool got_event;
 
     switch (cli_cqs_[thread_idx]->AsyncNext(&got_tag, &ok, short_deadline)) {
-      case CompletionQueue::SHUTDOWN: return false;
+      case CompletionQueue::SHUTDOWN:
+        return false;
       case CompletionQueue::TIMEOUT:
-	got_event = false;
-	break;
+        got_event = false;
+        break;
       case CompletionQueue::GOT_EVENT:
-	got_event = true;
-	break;
+        got_event = true;
+        break;
       default:
         GPR_ASSERT(false);
         break;
@@ -239,89 +242,87 @@ class AsyncClient : public Client {
       return false;
     }
     if (got_event) {
-     ClientRpcContext* ctx = ClientRpcContext::detag(got_tag);
-     if (ctx->RunNextState(ok, histogram) == false) {
-       // call the callback and then clone the ctx
-       ctx->RunNextState(ok, histogram);
-       ClientRpcContext *clone_ctx = ctx->StartNewClone();
-       if (closed_loop_) {
-         clone_ctx->Start(cli_cqs_[thread_idx].get());
-       }
-       else {
-         // Remove the entry from the rpc deadlines list
-         rpc_deadlines_[thread_idx].erase(ctx->deadline_posn());
-         // Put the clone_ctx in the list of idle contexts for this channel
-	 // Under lock
-	 int ch = clone_ctx->channel_id();
-	 std::lock_guard<std::mutex> g(channel_lock_[ch]);
-	 contexts_[ch].push_front(clone_ctx);
-       }
-       // delete the old version
-       delete ctx;
-     }
-     if (!closed_loop_)
-       issue_allowed_[thread_idx] = true; // may be ok now even if it hadn't been
-   }
-   if (!closed_loop_ && issue_allowed_[thread_idx] &&
-       grpc_time_source::now() >= next_issue_[thread_idx]) {
-     // Attempt to issue
-     bool issued = false;
-     for (int num_attempts = 0, channel_attempt = next_channel_[thread_idx];
-          num_attempts < channel_count_ && !issued; num_attempts++) {
-       bool can_issue = false;
-       ClientRpcContext* ctx = nullptr;
-       {
-         std::lock_guard<std::mutex>
-             g(channel_lock_[channel_attempt]);
-         if (!contexts_[channel_attempt].empty()) {
-           // Get an idle context from the front of the list
-           ctx = *(contexts_[channel_attempt].begin());
-           contexts_[channel_attempt].pop_front();
-           can_issue = true;
-         }
-       }
-       if (can_issue) {
-	 // do the work to issue
-         rpc_deadlines_[thread_idx].emplace_back(
-             grpc_time_source::now() + std::chrono::seconds(1));
-         auto it = rpc_deadlines_[thread_idx].end();
-         --it;
-         ctx->set_deadline_posn(it);
-         ctx->Start(cli_cqs_[thread_idx].get());
-	 issued = true;
-         // If we did issue, then next time, try our thread's next
-         // preferred channel
-         next_channel_[thread_idx] += pref_channel_inc_;
-         if (next_channel_[thread_idx] >= channel_count_)
-           next_channel_[thread_idx] = (thread_idx % channel_count_);
-       } else {
-         // Do a modular increment of channel attempt if we couldn't issue
-         channel_attempt = (channel_attempt+1) % channel_count_;
-       }
-     }
-     if (issued) {
-       // We issued one; see when we can issue the next
-       grpc_time next_issue;
-       NextIssueTime(thread_idx, &next_issue);
-       next_issue_[thread_idx]=next_issue;
-     }
-     else {
-       issue_allowed_[thread_idx] = false;
-     }
-   }
-   return true;
+      ClientRpcContext* ctx = ClientRpcContext::detag(got_tag);
+      if (ctx->RunNextState(ok, histogram) == false) {
+        // call the callback and then clone the ctx
+        ctx->RunNextState(ok, histogram);
+        ClientRpcContext* clone_ctx = ctx->StartNewClone();
+        if (closed_loop_) {
+          clone_ctx->Start(cli_cqs_[thread_idx].get());
+        } else {
+          // Remove the entry from the rpc deadlines list
+          rpc_deadlines_[thread_idx].erase(ctx->deadline_posn());
+          // Put the clone_ctx in the list of idle contexts for this channel
+          // Under lock
+          int ch = clone_ctx->channel_id();
+          std::lock_guard<std::mutex> g(channel_lock_[ch]);
+          contexts_[ch].push_front(clone_ctx);
+        }
+        // delete the old version
+        delete ctx;
+      }
+      if (!closed_loop_)
+        issue_allowed_[thread_idx] =
+            true;  // may be ok now even if it hadn't been
+    }
+    if (!closed_loop_ && issue_allowed_[thread_idx] &&
+        grpc_time_source::now() >= next_issue_[thread_idx]) {
+      // Attempt to issue
+      bool issued = false;
+      for (int num_attempts = 0, channel_attempt = next_channel_[thread_idx];
+           num_attempts < channel_count_ && !issued; num_attempts++) {
+        bool can_issue = false;
+        ClientRpcContext* ctx = nullptr;
+        {
+          std::lock_guard<std::mutex> g(channel_lock_[channel_attempt]);
+          if (!contexts_[channel_attempt].empty()) {
+            // Get an idle context from the front of the list
+            ctx = *(contexts_[channel_attempt].begin());
+            contexts_[channel_attempt].pop_front();
+            can_issue = true;
+          }
+        }
+        if (can_issue) {
+          // do the work to issue
+          rpc_deadlines_[thread_idx].emplace_back(grpc_time_source::now() +
+                                                  std::chrono::seconds(1));
+          auto it = rpc_deadlines_[thread_idx].end();
+          --it;
+          ctx->set_deadline_posn(it);
+          ctx->Start(cli_cqs_[thread_idx].get());
+          issued = true;
+          // If we did issue, then next time, try our thread's next
+          // preferred channel
+          next_channel_[thread_idx] += pref_channel_inc_;
+          if (next_channel_[thread_idx] >= channel_count_)
+            next_channel_[thread_idx] = (thread_idx % channel_count_);
+        } else {
+          // Do a modular increment of channel attempt if we couldn't issue
+          channel_attempt = (channel_attempt + 1) % channel_count_;
+        }
+      }
+      if (issued) {
+        // We issued one; see when we can issue the next
+        grpc_time next_issue;
+        NextIssueTime(thread_idx, &next_issue);
+        next_issue_[thread_idx] = next_issue;
+      } else {
+        issue_allowed_[thread_idx] = false;
+      }
+    }
+    return true;
   }
 
  private:
   std::vector<std::unique_ptr<CompletionQueue>> cli_cqs_;
 
-  std::vector<deadline_list> rpc_deadlines_; // per thread deadlines
-  std::vector<int> next_channel_; // per thread round-robin channel ctr
-  std::vector<bool> issue_allowed_; // may this thread attempt to issue
-  std::vector<grpc_time> next_issue_; // when should it issue?
+  std::vector<deadline_list> rpc_deadlines_;  // per thread deadlines
+  std::vector<int> next_channel_;      // per thread round-robin channel ctr
+  std::vector<bool> issue_allowed_;    // may this thread attempt to issue
+  std::vector<grpc_time> next_issue_;  // when should it issue?
 
   std::vector<std::mutex> channel_lock_;
-  std::vector<context_list> contexts_; // per-channel list of idle contexts
+  std::vector<context_list> contexts_;  // per-channel list of idle contexts
   int max_outstanding_per_channel_;
   int channel_count_;
   int pref_channel_inc_;
@@ -334,34 +335,31 @@ class AsyncUnaryClient GRPC_FINAL : public AsyncClient {
     StartThreads(config.async_client_threads());
   }
   ~AsyncUnaryClient() GRPC_OVERRIDE { EndThreads(); }
-private:
-  static ClientRpcContext *SetupCtx(int channel_id,
-				    TestService::Stub* stub,
-				    const SimpleRequest& req) {
+
+ private:
+  static ClientRpcContext* SetupCtx(int channel_id, TestService::Stub* stub,
+                                    const SimpleRequest& req) {
     auto check_done = [](grpc::Status s, SimpleResponse* response) {};
     auto start_req = [](TestService::Stub* stub, grpc::ClientContext* ctx,
                         const SimpleRequest& request, CompletionQueue* cq) {
       return stub->AsyncUnaryCall(ctx, request, cq);
     };
-    return new ClientRpcContextUnaryImpl<SimpleRequest,
-					 SimpleResponse>(channel_id, stub, req,
-							 start_req, check_done);
+    return new ClientRpcContextUnaryImpl<SimpleRequest, SimpleResponse>(
+        channel_id, stub, req, start_req, check_done);
   }
-  
 };
 
 template <class RequestType, class ResponseType>
 class ClientRpcContextStreamingImpl : public ClientRpcContext {
  public:
-  ClientRpcContextStreamingImpl(int channel_id,
-      TestService::Stub* stub, const RequestType& req,
-      std::function<std::unique_ptr<
-          grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>(
-              TestService::Stub*, grpc::ClientContext*, CompletionQueue*,
-              void*)> start_req,
+  ClientRpcContextStreamingImpl(
+      int channel_id, TestService::Stub* stub, const RequestType& req,
+      std::function<std::unique_ptr<grpc::ClientAsyncReaderWriter<
+          RequestType, ResponseType>>(TestService::Stub*, grpc::ClientContext*,
+                                      CompletionQueue*, void*)> start_req,
       std::function<void(grpc::Status, ResponseType*)> on_done)
       : ClientRpcContext(channel_id),
-	context_(),
+        context_(),
         stub_(stub),
         req_(req),
         response_(),
@@ -374,12 +372,13 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
     return (this->*next_state_)(ok, hist);
   }
   ClientRpcContext* StartNewClone() GRPC_OVERRIDE {
-    return new ClientRpcContextStreamingImpl(channel_id_,
-					     stub_, req_, start_req_, callback_);
+    return new ClientRpcContextStreamingImpl(channel_id_, stub_, req_,
+                                             start_req_, callback_);
   }
-  void Start(CompletionQueue *cq) GRPC_OVERRIDE {
+  void Start(CompletionQueue* cq) GRPC_OVERRIDE {
     stream_ = start_req_(stub_, &context_, cq, ClientRpcContext::tag(this));
   }
+
  private:
   bool ReqSent(bool ok, Histogram*) { return StartWrite(ok); }
   bool StartWrite(bool ok) {
@@ -411,8 +410,8 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
   std::function<void(grpc::Status, ResponseType*)> callback_;
   std::function<
       std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>(
-          TestService::Stub*, grpc::ClientContext*,
-          CompletionQueue *, void*)> start_req_;
+          TestService::Stub*, grpc::ClientContext*, CompletionQueue*, void*)>
+      start_req_;
   grpc::Status status_;
   double start_;
   std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>
@@ -430,20 +429,18 @@ class AsyncStreamingClient GRPC_FINAL : public AsyncClient {
   }
 
   ~AsyncStreamingClient() GRPC_OVERRIDE { EndThreads(); }
-private:
-  static ClientRpcContext *SetupCtx(int channel_id,
-                                    TestService::Stub* stub,
-                                    const SimpleRequest& req)  {
+
+ private:
+  static ClientRpcContext* SetupCtx(int channel_id, TestService::Stub* stub,
+                                    const SimpleRequest& req) {
     auto check_done = [](grpc::Status s, SimpleResponse* response) {};
     auto start_req = [](TestService::Stub* stub, grpc::ClientContext* ctx,
-                          CompletionQueue *cq, void* tag) {
+                        CompletionQueue* cq, void* tag) {
       auto stream = stub->AsyncStreamingCall(ctx, cq, tag);
       return stream;
     };
-    return new ClientRpcContextStreamingImpl<SimpleRequest,
-					     SimpleResponse>(channel_id, stub,
-							     req, start_req,
-							     check_done);
+    return new ClientRpcContextStreamingImpl<SimpleRequest, SimpleResponse>(
+        channel_id, stub, req, start_req, check_done);
   }
 };
 

test/cpp/qps/interarrival.h

@@ -55,53 +55,60 @@ class RandomDist {
   RandomDist() {}
   virtual ~RandomDist() = 0;
   // Argument to operator() is a uniform double in the range [0,1)
-  virtual double operator() (double uni) const = 0;
+  virtual double operator()(double uni) const = 0;
 };
 
 inline RandomDist::~RandomDist() {}
 
-class UniformDist GRPC_FINAL: public RandomDist {
-public:
- UniformDist(double lo, double hi): lo_(lo), range_(hi-lo) {}
- ~UniformDist() GRPC_OVERRIDE {}
- double operator() (double uni) const GRPC_OVERRIDE {return uni*range_+lo_;}
-private:
+class UniformDist GRPC_FINAL : public RandomDist {
+ public:
+  UniformDist(double lo, double hi) : lo_(lo), range_(hi - lo) {}
+  ~UniformDist() GRPC_OVERRIDE {}
+  double operator()(double uni) const GRPC_OVERRIDE {
+    return uni * range_ + lo_;
+  }
+
+ private:
   double lo_;
   double range_;
 };
 
 class ExpDist GRPC_FINAL : public RandomDist {
-public:
- explicit ExpDist(double lambda): lambda_recip_(1.0/lambda) {}
- ~ExpDist() GRPC_OVERRIDE {}
- double operator() (double uni) const GRPC_OVERRIDE {
-   // Note: Use 1.0-uni above to avoid NaN if uni is 0
-   return lambda_recip_ * (-log(1.0-uni));
- }
-private:
+ public:
+  explicit ExpDist(double lambda) : lambda_recip_(1.0 / lambda) {}
+  ~ExpDist() GRPC_OVERRIDE {}
+  double operator()(double uni) const GRPC_OVERRIDE {
+    // Note: Use 1.0-uni above to avoid NaN if uni is 0
+    return lambda_recip_ * (-log(1.0 - uni));
+  }
+
+ private:
   double lambda_recip_;
 };
 
 class DetDist GRPC_FINAL : public RandomDist {
-public:
- explicit DetDist(double val): val_(val) {}
- ~DetDist() GRPC_OVERRIDE {}
- double operator() (double uni) const GRPC_OVERRIDE {return val_;}
-private:
+ public:
+  explicit DetDist(double val) : val_(val) {}
+  ~DetDist() GRPC_OVERRIDE {}
+  double operator()(double uni) const GRPC_OVERRIDE { return val_; }
+
+ private:
   double val_;
 };
 
 class ParetoDist GRPC_FINAL : public RandomDist {
-public:
-  ParetoDist(double base, double alpha): base_(base), alpha_recip_(1.0/alpha) {}
+ public:
+  ParetoDist(double base, double alpha)
+      : base_(base), alpha_recip_(1.0 / alpha) {}
   ~ParetoDist() GRPC_OVERRIDE {}
-  double operator() (double uni) const GRPC_OVERRIDE {
-   // Note: Use 1.0-uni above to avoid div by zero if uni is 0
-    return base_ / pow(1.0-uni, alpha_recip_);
- }
-private:
- double base_;
- double alpha_recip_;
+  double operator()(double uni) const GRPC_OVERRIDE {
+    // Note: Use 1.0-uni above to avoid div by zero if uni is 0
+    return base_ / pow(1.0 - uni, alpha_recip_);
+  }
+
+ private:
+  double base_;
+  double alpha_recip_;
 };
 
 // A class library for generating pseudo-random interarrival times
@@ -111,38 +118,37 @@ private:
 using qps_random_engine = std::default_random_engine;
 
 class InterarrivalTimer {
-public:
+ public:
   InterarrivalTimer() {}
-  InterarrivalTimer(const RandomDist& r, int threads, int entries=1000000) {
+  InterarrivalTimer(const RandomDist& r, int threads, int entries = 1000000) {
     init(r, threads, entries);
   }
-  void init(const RandomDist& r, int threads, int entries=1000000) {
+  void init(const RandomDist& r, int threads, int entries = 1000000) {
     qps_random_engine gen;
-    std::uniform_real_distribution<double> uniform(0.0,1.0);
-    for (int i=0; i<entries; i++) {
-      random_table_.push_back(
-          std::chrono::nanoseconds(
-              static_cast<int64_t>(1e9*r(uniform(gen)))));
+    std::uniform_real_distribution<double> uniform(0.0, 1.0);
+    for (int i = 0; i < entries; i++) {
+      random_table_.push_back(std::chrono::nanoseconds(
+          static_cast<int64_t>(1e9 * r(uniform(gen)))));
     }
     // Now set up the thread positions
-    for (int i=0; i<threads; i++) {
-      thread_posns_.push_back(random_table_.begin() + (entries * i)/threads);
+    for (int i = 0; i < threads; i++) {
+      thread_posns_.push_back(random_table_.begin() + (entries * i) / threads);
     }
   }
-  virtual ~InterarrivalTimer() {};
+  virtual ~InterarrivalTimer(){};
 
-  std::chrono::nanoseconds operator() (int thread_num) {
+  std::chrono::nanoseconds operator()(int thread_num) {
     auto ret = *(thread_posns_[thread_num]++);
     if (thread_posns_[thread_num] == random_table_.end())
       thread_posns_[thread_num] = random_table_.begin();
     return ret;
   }
+
  private:
   typedef std::vector<std::chrono::nanoseconds> time_table;
   std::vector<time_table::const_iterator> thread_posns_;
   time_table random_table_;
 };
-
 }
 }
 

test/cpp/qps/qps_interarrival_test.cc

@@ -42,21 +42,21 @@
 using grpc::testing::ExpDist;
 using grpc::testing::InterarrivalTimer;
 
-void RunTest(InterarrivalTimer&& timer, std::string title) {
-  gpr_histogram *h(gpr_histogram_create(0.01,60e9));
-  
-  for (int i=0; i<10000000; i++) {
-    for (int j=0; j<5; j++) {
+void RunTest(InterarrivalTimer &&timer, std::string title) {
+  gpr_histogram *h(gpr_histogram_create(0.01, 60e9));
+
+  for (int i = 0; i < 10000000; i++) {
+    for (int j = 0; j < 5; j++) {
       gpr_histogram_add(h, timer(j).count());
     }
   }
-  
-  std::cout << title <<  " Distribution" << std::endl;
+
+  std::cout << title << " Distribution" << std::endl;
   std::cout << "Value, Percentile" << std::endl;
   for (double pct = 0.0; pct < 100.0; pct += 1.0) {
     std::cout << gpr_histogram_percentile(h, pct) << "," << pct << std::endl;
   }
-  
+
   gpr_histogram_destroy(h);
 }
 
@@ -68,9 +68,9 @@ using grpc::testing::ParetoDist;
 int main(int argc, char **argv) {
   RunTest(InterarrivalTimer(ExpDist(10.0), 5), std::string("Exponential(10)"));
   RunTest(InterarrivalTimer(DetDist(5.0), 5), std::string("Det(5)"));
-  RunTest(InterarrivalTimer(UniformDist(0.0,10.0), 5),
+  RunTest(InterarrivalTimer(UniformDist(0.0, 10.0), 5),
           std::string("Uniform(1,10)"));
-  RunTest(InterarrivalTimer(ParetoDist(1.0,1.0), 5),
+  RunTest(InterarrivalTimer(ParetoDist(1.0, 1.0), 5),
           std::string("Pareto(1,1)"));
 
   return 0;

test/cpp/qps/qpstest.proto

@@ -36,7 +36,7 @@ package grpc.testing;
 
 enum PayloadType {
   // Compressable text format.
-  COMPRESSABLE= 1;
+  COMPRESSABLE = 1;
 
   // Uncompressable binary format.
   UNCOMPRESSABLE = 2;
@@ -130,20 +130,21 @@ message LoadParams {
 message ClientConfig {
   repeated string server_targets = 1;
   required ClientType client_type = 2;
-  optional bool enable_ssl = 3 [default=false];
+  optional bool enable_ssl = 3 [default = false];
   required int32 outstanding_rpcs_per_channel = 4;
   required int32 client_channels = 5;
   required int32 payload_size = 6;
   // only for async client:
   optional int32 async_client_threads = 7;
-  optional RpcType rpc_type = 8 [default=UNARY];
+  optional RpcType rpc_type = 8 [default = UNARY];
   optional string host = 9;
-  optional LoadType load_type = 10 [default=CLOSED_LOOP];
+  optional LoadType load_type = 10 [default = CLOSED_LOOP];
   optional LoadParams load_params = 11;
 }
 
 // Request current stats
-message Mark {}
+message Mark {
+}
 
 message ClientArgs {
   oneof argtype {
@@ -165,8 +166,8 @@ message ClientStatus {
 
 message ServerConfig {
   required ServerType server_type = 1;
-  optional int32 threads = 2 [default=1];
-  optional bool enable_ssl = 3 [default=false];
+  optional int32 threads = 2 [default = 1];
+  optional bool enable_ssl = 3 [default = false];
   optional string host = 4;
 }
 
@@ -185,11 +186,11 @@ message ServerStatus {
 message SimpleRequest {
   // Desired payload type in the response from the server.
   // If response_type is RANDOM, server randomly chooses one from other formats.
-  optional PayloadType response_type = 1 [default=COMPRESSABLE];
+  optional PayloadType response_type = 1 [default = COMPRESSABLE];
 
   // Desired payload size in the response from the server.
   // If response_type is COMPRESSABLE, this denotes the size before compression.
-  optional int32 response_size = 2 [default=0];
+  optional int32 response_size = 2 [default = 0];
 
   // Optional input payload sent along with the request.
   optional Payload payload = 3;