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_socket_reuse_policy_penalty_coef = -1;
+
 }  // 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_score = -1;
+  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 score = 0;
+      int64 bytes_read = it->socket->NumBytesRead();
+      double num_kb = static_cast<double>(bytes_read) / 1024.0;
+
+      int idle_time_sec = (base::TimeTicks::Now() - it->start_time).InSeconds();
+      idle_time_sec = std::max(1, idle_time_sec);
+
+      if (g_socket_reuse_policy_penalty_coef >= 0) {
+        score = num_kb / pow(idle_time_sec,
+                             g_socket_reuse_policy_penalty_coef);
+
+        debug_log = StringPrintf("%s\n%f\t%d\t%f", debug_log.data(),

[Mike Belshe, 2011/06/12 22:10:35]

please remove the debug logging

[Gagan, 2011/06/14 18:25:02]

Done.

+                                 num_kb, idle_time_sec, score);
+      }
+
+      // Equality to prefer recently used connection.
+      if (score >= max_score) {
+        idle_socket_it = it;

[Mike Belshe, 2011/06/12 22:17:03]

Note:  This is basically a LIFO.  The old algorithm was FIFO.  Do you want to be
able to compare:

  LIFO/FIFO/warmest/warmest-scored?

Sorry to keep adding more to your change.

[Gagan, 2011/06/13 03:52:47]

Agreed, this behaves like LIFO when response sizes are similar.
We have a field trial for FIFO, warmest and warmest scored. And i don't think
FIFO adds any value, we choose it because it simulates warmest first. So i think
we are covered for now. We should revisit this once we have some data.

Hopefully over a period of time we should be able to see meaningful data. In any
case, i can use the command line flag to use warmest first.
On blink.boutiques.com, warmest first produces awesome results, and i'm sure
there will be other sites as well where this will be useful, though may not be
so easy to measure as its on blink.boutiques.com (try it, from remote countries
like india you see a huge cut down in variability and latency).
 
np.

+        max_score = score;
+        best_pair = std::make_pair(bytes_read, idle_time_sec);
+        rtt_ms = it->socket->GetConnectTimeMicros();
+      }
     }
 
     ++it;
   }
+  debug_log = StringPrintf("%s\nChose socket <%d %ld>\nRtt = %f",
+                           debug_log.data(),

[Mike Belshe, 2011/06/12 22:10:35]

please remove the debug logging.

[Gagan, 2011/06/14 18:25:02]

Done.

+                           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 188 matching lines @@
     return;
 
   // Current time value. Retrieving it once at the function start rather than
   // inside the inner loop, since it shouldn't change by any meaningful amount.
   base::TimeTicks now = base::TimeTicks::Now();
 
   GroupMap::iterator i = group_map_.begin();
   while (i != group_map_.end()) {
     Group* group = i->second;
 
     std::list<IdleSocket>::iterator j = group->mutable_idle_sockets()->begin();

[Mike Belshe, 2011/06/12 22:17:03]

BTW - do we need to clean out the socket with the fewest bytes sent on it? 
Otherwise, your algorithm might not work as well as expected.

[Gagan, 2011/06/13 03:52:47]

Didn't get you. the timeout for cleaning up socket is anyways 5 minutes, so if a
socket is unused for 5 mins, its a candidate for cleanup.
Are you suggesting a higher timeout for warmest socket ?

     while (j != group->idle_sockets().end()) {
       base::TimeDelta timeout =
           j->socket->WasEverUsed() ?
           used_idle_socket_timeout_ : unused_idle_socket_timeout_;
       if (force || j->ShouldCleanup(now, timeout)) {
         delete j->socket;
         j = group->mutable_idle_sockets()->erase(j);
         DecrementIdleCount();
       } else {
         ++j;
@@ skipping 36 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(int policy) {
+  double old_value = g_socket_reuse_policy_penalty_coef;
+  g_socket_reuse_policy_penalty_coef =
+      policy == USE_WARMEST_SOCKET ? 0 :
+      (policy == USE_WARM_SOCKET ? 0.25 : -1);
+  DLOG(INFO) << "Setting g_socket_reuse_policy_penalty_coef = "
+             << g_socket_reuse_policy_penalty_coef;
+  // TODO(gagan): Remove this.
+  LOG(ERROR) << "Setting g_socket_reuse_policy_penalty_coef = "
+             << g_socket_reuse_policy_penalty_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