average per minute with tests

Author: scotthart

google/cloud/bigtable/internal/bigtable_random_two_least_used_decorator.cc

@@ -329,7 +329,7 @@ BigtableRandomTwoLeastUsed::AsyncPrepareQuery(
   return result;
 }
 
-std::shared_ptr<ChannelUsageWrapper<BigtableStub>>
+std::shared_ptr<ChannelUsage<BigtableStub>>
 BigtableRandomTwoLeastUsed::Child() {
   std::cout << __PRETTY_FUNCTION__ << std::endl;
   return pool_->GetChannelRandomTwoLeastUsed();

google/cloud/bigtable/internal/bigtable_random_two_least_used_decorator.h

@@ -129,9 +129,7 @@ class BigtableRandomTwoLeastUsed : public BigtableStub {
       google::bigtable::v2::PrepareQueryRequest const& request) override;
 
  private:
-  std::shared_ptr<ChannelUsageWrapper<BigtableStub>> Child();
-
-  //  std::mutex mu_;
+  std::shared_ptr<ChannelUsage<BigtableStub>> Child();
   std::shared_ptr<DynamicChannelPool<BigtableStub>> pool_;
 };
 

google/cloud/bigtable/internal/bigtable_stub_factory.cc

@@ -85,30 +85,34 @@ std::shared_ptr<BigtableStub> CreateBigtableStubRandomTwoLeastUsed(
 
   auto refreshing_channel_stub_factory =
       [stub_factory = std::move(stub_factory), cq_impl, refresh_state,
-       auth = std::move(auth), options](std::uint32_t id)
-      -> std::shared_ptr<ChannelUsageWrapper<BigtableStub>> {
-    auto wrapper = std::make_shared<ChannelUsageWrapper<BigtableStub>>();
+       auth = std::move(auth), options](
+          std::uint32_t id,
+          bool prime_channel) -> std::shared_ptr<ChannelUsage<BigtableStub>> {
+    auto wrapper = std::make_shared<ChannelUsage<BigtableStub>>();
     auto connection_status_fn = [weak = wrapper->MakeWeak()](Status const& s) {
       if (auto self = weak.lock()) {
-        self->SetLastRefreshStatus(s);
+        self->set_last_refresh_status(s);
       }
       if (!s.ok()) {
         GCP_LOG(WARNING) << "Failed to refresh connection. Error: " << s;
       }
     };
     auto channel = CreateGrpcChannel(*auth, options, id);
+    if (prime_channel) {
+      (void)channel->GetState(true);
+    }
     ScheduleChannelRefresh(cq_impl, refresh_state, channel,
                            std::move(connection_status_fn));
     wrapper->set_channel(stub_factory(std::move(channel)));
     return wrapper;
   };
 
-  std::vector<std::shared_ptr<ChannelUsageWrapper<BigtableStub>>> children(
+  std::vector<std::shared_ptr<ChannelUsage<BigtableStub>>> children(
       std::max(1, options.get<GrpcNumChannelsOption>()));
   std::uint32_t id = 0;
   std::generate(children.begin(), children.end(),
                 [&id, &refreshing_channel_stub_factory] {
-                  return refreshing_channel_stub_factory(id++);
+                  return refreshing_channel_stub_factory(id++, false);
                 });
 
   return std::make_shared<BigtableRandomTwoLeastUsed>(

google/cloud/bigtable/internal/connection_refresh_state.cc

@@ -30,6 +30,12 @@ namespace {
  */
 auto constexpr kConnectionReadyTimeout = std::chrono::seconds(10);
 
+void LogFailedConnectionRefresh(Status const& conn_status) {
+  if (!conn_status.ok()) {
+    GCP_LOG(WARNING) << "Failed to refresh connection. Error: " << conn_status;
+  }
+}
+
 }  // namespace
 
 ConnectionRefreshState::ConnectionRefreshState(
@@ -53,12 +59,6 @@ bool ConnectionRefreshState::enabled() const {
   return max_conn_refresh_period_.count() != 0;
 }
 
-void LogFailedConnectionRefresh(Status const& conn_status) {
-  if (!conn_status.ok()) {
-    GCP_LOG(WARNING) << "Failed to refresh connection. Error: " << conn_status;
-  }
-}
-
 void ScheduleChannelRefresh(
     std::shared_ptr<internal::CompletionQueueImpl> const& cq_impl,
     std::shared_ptr<ConnectionRefreshState> const& state,