Deciding best connection to schedule requests on based on cwnd and idle time

net/socket/client_socket_pool_base.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/client_socket_pool_base.h"
 
+#include <math.h>
+#include <utility>
+#include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
+#include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
 #include "base/stl_util-inl.h"
+#include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "net/base/net_log.h"
 #include "net/base/net_errors.h"
 #include "net/socket/client_socket_handle.h"
 
 using base::TimeDelta;
 
 namespace {
 
 // The timeout value, in seconds, used to clean up idle sockets that can't be
 // reused.
 //
 // Note: It's important to close idle sockets that have received data as soon
 // as possible because the received data may cause BSOD on Windows XP under
 // some conditions.  See http://crbug.com/4606.
 const int kCleanupInterval = 10;  // DO NOT INCREASE THIS TIMEOUT.
 
 // Indicate whether or not we should establish a new transport layer connection
 // after a certain timeout has passed without receiving an ACK.
 bool g_connect_backup_jobs_enabled = true;
 
+// Alpha.
+double g_bytes_read_vs_last_accessed_alpha = 1000000;
+
 }  // namespace
 
 namespace net {
 
 ConnectJob::ConnectJob(const std::string& group_name,
                        base::TimeDelta timeout_duration,
                        Delegate* delegate,
                        const BoundNetLog& net_log)
     : group_name_(group_name),
       timeout_duration_(timeout_duration),
@@ skipping 311 matching lines @@
     }
   }
 
   return rv;
 }
 
 bool ClientSocketPoolBaseHelper::AssignIdleSocketToGroup(
     const Request* request, Group* group) {
   std::list<IdleSocket>* idle_sockets = group->mutable_idle_sockets();
   std::list<IdleSocket>::iterator idle_socket_it = idle_sockets->end();
+  double max_benefit = -100000000;
+  std::pair<int, int64> best_pair;
+
+  std::string debug_log(request->handle()->group_name());
+  std::string candidates;
+  double rtt_ms = 0;
 
   // Iterate through the idle sockets forwards (oldest to newest)
   //   * Delete any disconnected ones.
   //   * If we find a used idle socket, assign to |idle_socket|.  At the end,
   //   the |idle_socket_it| will be set to the newest used idle socket.
   for (std::list<IdleSocket>::iterator it = idle_sockets->begin();
        it != idle_sockets->end();) {
     if (!it->socket->IsConnectedAndIdle()) {
       DecrementIdleCount();
       delete it->socket;
       it = idle_sockets->erase(it);
       continue;
     }
 
     if (it->socket->WasEverUsed()) {
       // We found one we can reuse!
-      idle_socket_it = it;
+      int bytes_read = it->socket->NumBytesRead();
+      double B = static_cast<double>(bytes_read) / 1024.0;
+
+      int64 idle_time = (base::TimeTicks::Now() - it->start_time)
+          .InMicroseconds();
+      double idle_time_mins = static_cast<double>(idle_time) / 60000000.0;
+      double T = pow(g_bytes_read_vs_last_accessed_alpha, idle_time_mins);
+
+      debug_log = StringPrintf("%s\n%f\t%f\t%f",
+                               debug_log.data(), B, idle_time_mins, T);
+      double benefit = B - T;
+
+      // Equality to prefer recently used connection.
+      if (benefit >= max_benefit) {
+        idle_socket_it = it;
+        max_benefit = benefit;
+        best_pair = std::make_pair(bytes_read, idle_time);
+        rtt_ms = it->socket->GetRTTInMs();
+      }
     }
 
     ++it;
   }
+  debug_log = StringPrintf("%s\nChose socket <%d %lld>\nRtt = %f",
+                           debug_log.data(),
+                           best_pair.first, best_pair.second,
+                           rtt_ms);
+  LOG(ERROR) << "\n\n----------------------------------------" << debug_log;
 
   // If we haven't found an idle socket, that means there are no used idle
   // sockets.  Pick the oldest (first) idle socket (FIFO).
 
   if (idle_socket_it == idle_sockets->end() && !idle_sockets->empty())
     idle_socket_it = idle_sockets->begin();
 
   if (idle_socket_it != idle_sockets->end()) {
     DecrementIdleCount();
     base::TimeDelta idle_time =
@@ skipping 245 matching lines @@
   return g_connect_backup_jobs_enabled;
 }
 
 // static
 bool ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(bool enabled) {
   bool old_value = g_connect_backup_jobs_enabled;
   g_connect_backup_jobs_enabled = enabled;
   return old_value;
 }
 
+// static
+double ClientSocketPoolBaseHelper::set_bytes_read_vs_last_accessed_alpha(
+    double alpha) {
+  LOG(ERROR) << "Setting g_bytes_read_vs_last_accessed_alpha = " << alpha;
+  double old_value = g_bytes_read_vs_last_accessed_alpha;
+  g_bytes_read_vs_last_accessed_alpha = alpha;
+  return old_value;
+}
+
 void ClientSocketPoolBaseHelper::EnableConnectBackupJobs() {
   connect_backup_jobs_enabled_ = g_connect_backup_jobs_enabled;
 }
 
 void ClientSocketPoolBaseHelper::IncrementIdleCount() {
   if (++idle_socket_count_ == 1)
     timer_.Start(TimeDelta::FromSeconds(kCleanupInterval), this,
                  &ClientSocketPoolBaseHelper::OnCleanupTimerFired);
 }
 
@@ skipping 419 matching lines @@
   // Delete active jobs.
   STLDeleteElements(&jobs_);
 
   // Cancel pending backup job.
   method_factory_.RevokeAll();
 }
 
 }  // namespace internal
 
 }  // namespace net