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;
 
+// Decay coef.
+double g_tcp_socket_estimated_cwnd_decay_coef = 0;
+
 }  // 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, current_pair;
+
+  std::string debug_log(request->handle()->group_name());
+  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;
+      double benefit = 0;

[Mike Belshe, 2011/06/10 18:11:42]

My thoughts on this function:

* You're calculating a score for each socket based on number of bytes sent and
dampened by idle time.

* Idle times measured in minutes probably aren't that useful, since we tend to
timeout sockets faster than that.

* Damping functions usually damp exponentially (you have this already)

Current score is:
  score = num_kb_sent - (coef ^ idle_time_in_mins)

Note:  scores are unbounded here and eventually go negative.  This function only
appears to work because time was converted to minutes.  Try using seconds, and
the damping goes out of whack very quickly.

Proposal:
  idle_time = min(1, idle_time_in_sec);
  score = num_kb_sent / (idle_time_in_sec ^ coef)
  coef == 0.25 (my guess)

  Note:  the minimum score here is 0, and the damping works fine with seconds,
giving us damping across reasonable units (seconds), and it scales up to any
value.

I'll send you a spreadsheet comparing these two separately.

[Gagan, 2011/06/12 20:11:44]

This function penalizes num_kb lesser than the older function, plus looks nice,
so using it.
Thanks for the suggestion.

+      int64 bytes_read = it->socket->NumBytesRead();
+      double num_kb = 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;
+
+      if (g_tcp_socket_estimated_cwnd_decay_coef > 0) {
+        double decay = pow(g_tcp_socket_estimated_cwnd_decay_coef,
+                           idle_time_mins);
+
+        debug_log = StringPrintf("%s\n%f\t%f\t%f", debug_log.data(),
+                                 num_kb, idle_time_mins, decay);
+        // Cwnd of a socket is estimated as the number of kilobytes
+        // transferred on it minus a decay function which is estimated as decay
+        // coef exponentiated by idle time in minutes.
+        // decay coef = 1 simulates no decay (cwnd validation disabled).
+        // decay coef = 1.83 simulates a decay of 20KB in 5 minutes.
+        benefit = num_kb - decay;
+      }
+
+      // 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->GetConnectTimeMicros();
+      }
     }
 
     ++it;
   }
+  debug_log = StringPrintf("%s\nChose socket <%d %ld>\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::SetSocketReusePolicy(
+    ClientSocketReusePolicy policy) {
+  double old_value = g_tcp_socket_estimated_cwnd_decay_coef;
+  g_tcp_socket_estimated_cwnd_decay_coef =
+      policy == USE_WARMEST_SOCKET ? 1 :
+      (policy == USE_WARM_SOCKET ? 1.83841629 : 0);
+  DLOG(INFO) << "Setting g_tcp_socket_estimated_cwnd_decay_coef = "
+             << g_tcp_socket_estimated_cwnd_decay_coef;
+  // TODO(gagan): Remove this.
+  LOG(ERROR) << "Setting g_tcp_socket_estimated_cwnd_decay_coef = "
+             << g_tcp_socket_estimated_cwnd_decay_coef;
+  return old_value;
+}
+
+// static
+double ClientSocketPoolBaseHelper::set_tcp_socket_estimated_cwnd_decay_coef(
+    double coef) {
+  DLOG(INFO) << "Setting g_tcp_socket_estimated_cwnd_decay_coef = " << coef;
+  LOG(ERROR) << "Setting g_tcp_socket_estimated_cwnd_decay_coef = " << coef;
+  double old_value = g_tcp_socket_estimated_cwnd_decay_coef;
+  g_tcp_socket_estimated_cwnd_decay_coef = coef;
+  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