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

net/http/http_basic_stream.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/http/http_basic_stream.h"
 
+#include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_parser.h"
 #include "net/http/http_util.h"
 #include "net/socket/client_socket_handle.h"
 
 namespace net {
 
+// static
+std::string HttpBasicStream::g_warm_connection_field_trial_group_;
+
 HttpBasicStream::HttpBasicStream(ClientSocketHandle* connection,
                                  HttpStreamParser* parser,
                                  bool using_proxy)
     : read_buf_(new GrowableIOBuffer()),
       parser_(parser),
       connection_(connection),
       using_proxy_(using_proxy),
       request_info_(NULL) {
 }
 
 HttpBasicStream::~HttpBasicStream() {}
 
 int HttpBasicStream::InitializeStream(const HttpRequestInfo* request_info,
                                       const BoundNetLog& net_log,
                                       CompletionCallback* callback) {
   DCHECK(!parser_.get());
   request_info_ = request_info;
   parser_.reset(new HttpStreamParser(connection_.get(), request_info,
                                      read_buf_, net_log));
+  bytes_read_offset_ = connection_->socket()->NumBytesRead();
   return OK;
 }
 
 
 int HttpBasicStream::SendRequest(const HttpRequestHeaders& headers,
                                  UploadDataStream* request_body,
                                  HttpResponseInfo* response,
                                  CompletionCallback* callback) {
   DCHECK(parser_.get());
   DCHECK(request_info_);
   const std::string path = using_proxy_ ?
                            HttpUtil::SpecForRequest(request_info_->url) :
                            HttpUtil::PathForRequest(request_info_->url);
   request_line_ = base::StringPrintf("%s %s HTTP/1.1\r\n",
                                      request_info_->method.c_str(),
                                      path.c_str());
+  response_ = response;
   return parser_->SendRequest(request_line_, headers, request_body, response,
                               callback);
 }
 
 uint64 HttpBasicStream::GetUploadProgress() const {
   return parser_->GetUploadProgress();
 }
 
 int HttpBasicStream::ReadResponseHeaders(CompletionCallback* callback) {
   return parser_->ReadResponseHeaders(callback);
@@ skipping 49 matching lines @@
 
 void HttpBasicStream::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   parser_->GetSSLCertRequestInfo(cert_request_info);
 }
 
 bool HttpBasicStream::IsSpdyHttpStream() const {
   return false;
 }
 
+void HttpBasicStream::LogNumRttVsBytesMetrics() const {
+  int64 total_bytes_read = connection_->socket()->NumBytesRead();
+  int64 bytes_received = total_bytes_read - bytes_read_offset_;
+  int64 num_kb = bytes_received / 1024;
+  double rtt = connection_->socket()->GetConnectTimeMicros() / 1000;
+
+  if (num_kb < 1024 && rtt > 0) {  // Ignore responses > 1MB
+    base::TimeDelta duration = base::Time::Now() -
+                               response_->request_time;
+    double num_rtt = static_cast<double>(duration.InMilliseconds()) / rtt;
+    int64 num_rtt_scaled = (4 * num_rtt);
+
+    // Integer representation of <num_kb, num_rtt_scaled> tuple.
+    int val = 1024 * num_rtt_scaled + num_kb;

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

I think this is ridiculous still.  I see that you're generating a num_kb which
is 0 to 1024, and combining that with a num_rtt which has been multiplied to
offset it within the value.

But what is the point of such a histogram?  Histograms go into exponential
buckets, and this is just two independent values mixed - you'll end up with a
really whacky plot.  You won't have meaningful data here, because histogram
buckets are not linear.

You'll not like this, but you can collect multiple buckets of RTTs.  So you
could do num RTTs for 0-10KB, number of RTTs for 10-20KB, number of RTTS for
20-30KB, etc.

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

Done.

+
+    std::string histogram = "Net.RTT_vs_KB_";
+    histogram.append(g_warm_connection_field_trial_group_);

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

OK - I see, g_warm_connection_field_trial_group is constant, so the histogram
string will always be the same for any single instance of the browser.

I think the code you're looking for is this:

HISTOGRAM_CUSTOM_COUNTS(FieldTrial::MakeName(std::string("Net.RTT_vs_KB"),
g_warm_connection_field_trial_group_), <etc>

BTW -

If you want us to be able to see the numbers from the field you need to use

UMA_HISTOGRAM_CUSTOM_COUNTS instead of HISTOGRAM_CUSTOM_COUNTS

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

Done.

+    HISTOGRAM_CUSTOM_COUNTS(histogram, val, 4096, 3048000, 1000);
+    LOG(ERROR) << request_line_
+               << "\nrtt = " << rtt << "\tnum_rtt = " << num_rtt
+               << "\tnum_kb = " << num_kb << "\tval = " << val
+               << "\ttotal bytes = " << total_bytes_read;
+  }
+}
+
 }  // namespace net