feat(storage): reduce overhead in pooled handle factory (#6169)

Replace `std::vector<>` with `std::deque<>` because when the pool grows
too large we want to remove the *oldest* handles (fron the front). Also,
use a while loop during cleanup because it makes the intent clearer. I
expect that while loop to run at most once, but why force humans to
think this through?

Author: coryan

google/cloud/storage/internal/curl_handle_factory.cc

@@ -74,10 +74,7 @@ void DefaultCurlHandleFactory::CleanupMultiHandle(CurlMulti&& m) { m.reset(); }
 
 PooledCurlHandleFactory::PooledCurlHandleFactory(std::size_t maximum_size,
                                                  ChannelOptions options)
-    : maximum_size_(maximum_size), options_(std::move(options)) {
-  handles_.reserve(maximum_size);
-  multi_handles_.reserve(maximum_size);
-}
+    : maximum_size_(maximum_size), options_(std::move(options)) {}
 
 PooledCurlHandleFactory::~PooledCurlHandleFactory() {
   for (auto* h : handles_) {
@@ -111,7 +108,7 @@ void PooledCurlHandleFactory::CleanupHandle(CurlHandle&& h) {
   if (res == CURLE_OK && ip != nullptr) {
     last_client_ip_address_ = ip;
   }
-  if (handles_.size() >= maximum_size_) {
+  while (handles_.size() >= maximum_size_) {
     auto* tmp = handles_.front();
     handles_.erase(handles_.begin());
     curl_easy_cleanup(tmp);
@@ -133,7 +130,7 @@ CurlMulti PooledCurlHandleFactory::CreateMultiHandle() {
 
 void PooledCurlHandleFactory::CleanupMultiHandle(CurlMulti&& m) {
   std::unique_lock<std::mutex> lk(mu_);
-  if (multi_handles_.size() >= maximum_size_) {
+  while (multi_handles_.size() >= maximum_size_) {
     auto* tmp = multi_handles_.front();
     multi_handles_.erase(multi_handles_.begin());
     curl_multi_cleanup(tmp);

google/cloud/storage/internal/curl_handle_factory.h

@@ -18,9 +18,9 @@
 #include "google/cloud/storage/internal/curl_handle.h"
 #include "google/cloud/storage/internal/curl_wrappers.h"
 #include "google/cloud/storage/version.h"
+#include <deque>
 #include <mutex>
 #include <string>
-#include <vector>
 
 namespace google {
 namespace cloud {
@@ -114,8 +114,8 @@ class PooledCurlHandleFactory : public CurlHandleFactory {
  private:
   std::size_t maximum_size_;
   mutable std::mutex mu_;
-  std::vector<CURL*> handles_;
-  std::vector<CURLM*> multi_handles_;
+  std::deque<CURL*> handles_;
+  std::deque<CURLM*> multi_handles_;
   std::string last_client_ip_address_;
   ChannelOptions options_;
 };