Use Histogram algorithm to calculate DNS timeout. Honor DnsConfig timeout if it exceeds 5s.

net/dns/dns_session.cc

 // Copyright (c) 2012 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/dns/dns_session.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
@@ skipping 20 matching lines @@
 const size_t kRTTBucketCount = 100;
 // Target percentile in the RTT histogram used for retransmission timeout.
 const unsigned kRTOPercentile = 99;
 }  // namespace
 
 // Runtime statistics of DNS server.
 struct DnsSession::ServerStats {
   ServerStats(base::TimeDelta rtt_estimate_param, RttBuckets* buckets)
     : last_failure_count(0), rtt_estimate(rtt_estimate_param) {
     rtt_histogram.reset(new base::SampleVector(buckets));
+    // Seed histogram with 2 samples at |rtt_estimate| timeout.
+    rtt_histogram->Accumulate(rtt_estimate.InMilliseconds(), 2);
   }
 
   // Count of consecutive failures after last success.
   int last_failure_count;
 
   // Last time when server returned failure or timeout.
   base::Time last_failure;
   // Last time when server returned success.
   base::Time last_success;
 
@@ skipping 31 matching lines @@
                        NetLog* net_log)
     : config_(config),
       socket_pool_(socket_pool.Pass()),
       rand_callback_(base::Bind(rand_int_callback, 0, kuint16max)),
       net_log_(net_log),
       server_index_(0) {
   socket_pool_->Initialize(&config_.nameservers, net_log);
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "AsyncDNS.ServerCount", config_.nameservers.size(), 0, 10, 10);
   for (size_t i = 0; i < config_.nameservers.size(); ++i) {
-    server_stats_.push_back(new ServerStats(config_.timeout,
-                                            rtt_buckets_.Pointer()));
+    // Histogram-based method.

[szym, 2013/07/25 22:47:24]

This comment can be misleading. Suggest undoing this change.

[mef, 2013/07/26 11:27:07]

Done.

+    server_stats_.push_back(
+        new ServerStats(config_.timeout, rtt_buckets_.Pointer()));
   }
 }
 
 DnsSession::~DnsSession() {
   RecordServerStats();
 }
 
 int DnsSession::NextQueryId() const { return rand_callback_.Run(); }
 
 unsigned DnsSession::NextFirstServerIndex() {
@@ skipping 98 matching lines @@
       } else {
         UMA_HISTOGRAM_COUNTS("AsyncDNS.ServerFailuresAfterSuccess",
                              server_stats_[index]->last_failure_count);
       }
     }
   }
 }
 
 
 base::TimeDelta DnsSession::NextTimeout(unsigned server_index, int attempt) {
-  DCHECK_LT(server_index, server_stats_.size());
-
-  base::TimeDelta timeout = config_.timeout;
-  // If this server has not responded successfully, then don't wait too long.
-  if (server_stats_[server_index]->last_success.is_null())
-    return timeout;
-
-  // The timeout doubles every full round (each nameserver once).
-  unsigned num_backoffs = attempt / config_.nameservers.size();
-
-  return std::min(timeout * (1 << num_backoffs),
-                  base::TimeDelta::FromMilliseconds(kMaxTimeoutMs));
+  // Respect config timeout if it exceeds |kMaxTimeoutMs|.
+  if (config_.timeout.InMilliseconds() > kMaxTimeoutMs)

[szym, 2013/07/25 22:47:24]

should it be >=?

[mef, 2013/07/26 11:27:07]

Done.

+    return config_.timeout;
+  // Use Histogram to calculate next timeout.

[szym, 2013/07/25 22:47:24]

nit: superfluous comment

[mef, 2013/07/26 11:27:07]

Done.

+  return NextTimeoutFromHistogram(server_index, attempt);
 }
 
 // Allocate a socket, already connected to the server address.
 scoped_ptr<DnsSession::SocketLease> DnsSession::AllocateSocket(
     unsigned server_index, const NetLog::Source& source) {
   scoped_ptr<DatagramClientSocket> socket;
 
   socket = socket_pool_->AllocateSocket(server_index);
   if (!socket.get())
     return scoped_ptr<SocketLease>();
@@ skipping 61 matching lines @@
   timeout = std::max(timeout, base::TimeDelta::FromMilliseconds(kMinTimeoutMs));
 
   // The timeout still doubles every full round.
   unsigned num_backoffs = attempt / config_.nameservers.size();
 
   return std::min(timeout * (1 << num_backoffs),
                   base::TimeDelta::FromMilliseconds(kMaxTimeoutMs));
 }
 
 }  // namespace net