Landing Recent QUIC changes until 2016-07-02 02:45 UTC

net/quic/congestion_control/send_algorithm_simulator.cc

 // Copyright 2014 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/quic/congestion_control/send_algorithm_simulator.h"
 
 #include <stdint.h>
 
 #include <limits>
 
@@ skipping 80 matching lines @@
   pending_transfers_.back().sender->RecordStats();
 }
 
 void SendAlgorithmSimulator::TransferBytes() {
   TransferBytes(std::numeric_limits<uint64_t>::max(),
                 QuicTime::Delta::Infinite());
 }
 
 void SendAlgorithmSimulator::TransferBytes(QuicByteCount max_bytes,
                                            QuicTime::Delta max_time) {
-  const QuicTime end_time =
-      max_time.IsInfinite() ? QuicTime::Zero().Add(QuicTime::Delta::Infinite())
-                            : clock_->Now().Add(max_time);
+  const QuicTime end_time = max_time.IsInfinite()
+                                ? QuicTime::Zero() + QuicTime::Delta::Infinite()
+                                : clock_->Now() + max_time;
   QuicByteCount bytes_sent = 0;
   while (!pending_transfers_.empty() && clock_->Now() < end_time &&
          bytes_sent < max_bytes) {
     // Determine the times of next send and of the next ack arrival.
     PacketEvent send_event = NextSendEvent();
     PacketEvent ack_event = NextAckEvent();
     // If both times are infinite, fire a TLP.
     if (ack_event.time_delta.IsInfinite() &&
         send_event.time_delta.IsInfinite()) {
       DVLOG(1) << "Both times are infinite, simulating a TLP.";
@@ skipping 24 matching lines @@
 SendAlgorithmSimulator::PacketEvent SendAlgorithmSimulator::NextSendEvent() {
   QuicTime::Delta next_send_time = QuicTime::Delta::Infinite();
   Transfer* transfer = nullptr;
   for (vector<Transfer>::iterator it = pending_transfers_.begin();
        it != pending_transfers_.end(); ++it) {
     // If we've already sent enough bytes, wait for them to be acked.
     if (it->bytes_acked + it->bytes_in_flight >= it->num_bytes) {
       continue;
     }
     // If the flow hasn't started, use the start time.
-    QuicTime::Delta transfer_send_time = it->start_time.Subtract(clock_->Now());
+    QuicTime::Delta transfer_send_time = it->start_time - clock_->Now();
     if (clock_->Now() >= it->start_time) {
       transfer_send_time = it->sender->send_algorithm->TimeUntilSend(
           clock_->Now(), it->bytes_in_flight);
     }
     if (transfer_send_time < next_send_time) {
       next_send_time = transfer_send_time;
       transfer = &(*it);
     }
   }
   DVLOG(1) << "NextSendTime returning delta(ms):"
@@ skipping 59 matching lines @@
     // Skip over any packets less than or equal to last_acked.
     if (it->packet_number <= last_acked) {
       continue;
     }
     // Lost packets don't trigger an ack.
     if (it->lost) {
       continue;
     }
     DCHECK_LT(*next_acked, it->packet_number);
     // Consider a delayed ack for the current next_acked.
-    if (ack_delay < it->ack_time.Subtract(clock_->Now())) {
+    if (ack_delay < it->ack_time - clock_->Now()) {
       break;
     }
     *next_acked = it->packet_number;
-    ack_delay = it->ack_time.Subtract(clock_->Now());
+    ack_delay = it->ack_time - clock_->Now();
     if (HasRecentLostPackets(transfer, *next_acked) ||
         (*next_acked - last_acked) >= 2) {
       break;
     }
-    ack_delay = ack_delay.Add(delayed_ack_timer_);
+    ack_delay = ack_delay + delayed_ack_timer_;
   }
 
   DVLOG(1) << "FindNextAck found next_acked_:" << transfer->sender->next_acked
            << " last_acked:" << transfer->sender->last_acked
            << " ack_time(ms):" << ack_delay.ToMilliseconds();
   return ack_delay;
 }
 
 bool SendAlgorithmSimulator::HasRecentLostPackets(
     const Transfer* transfer,
@@ skipping 53 matching lines @@
     // This packet has been acked or lost, remove it from sent_packets_.
     largest_observed = *it;
     sent_packets_.erase(it++);
   }
 
   DCHECK(!largest_observed.lost);
   DVLOG(1) << "Updating RTT from send_time:"
            << largest_observed.send_time.ToDebuggingValue()
            << " to ack_time:" << largest_observed.ack_time.ToDebuggingValue();
   QuicTime::Delta measured_rtt =
-      largest_observed.ack_time.Subtract(largest_observed.send_time);
+      largest_observed.ack_time - largest_observed.send_time;
   DCHECK_GE(measured_rtt.ToMicroseconds(), rtt_.ToMicroseconds());
   sender->rtt_stats->UpdateRtt(measured_rtt, QuicTime::Delta::Zero(),
                                clock_->Now());
   sender->send_algorithm->OnCongestionEvent(true, transfer->bytes_in_flight,
                                             acked_packets, lost_packets);
   DCHECK_LE(kPacketSize * (acked_packets.size() + lost_packets.size()),
             transfer->bytes_in_flight);
   transfer->bytes_in_flight -=
       kPacketSize * (acked_packets.size() + lost_packets.size());
 
   sender->RecordStats();
   transfer->bytes_acked += acked_packets.size() * kPacketSize;
   transfer->bytes_lost += lost_packets.size() * kPacketSize;
   if (transfer->bytes_acked >= transfer->num_bytes) {
     // Remove completed transfers and record transfer bandwidth.
-    QuicTime::Delta transfer_time =
-        clock_->Now().Subtract(transfer->start_time);
+    QuicTime::Delta transfer_time = clock_->Now() - transfer->start_time;
     sender->last_transfer_loss_rate =
         static_cast<float>(transfer->bytes_lost) /
         (transfer->bytes_lost + transfer->bytes_acked);
     sender->last_transfer_bandwidth = QuicBandwidth::FromBytesAndTimeDelta(
         transfer->num_bytes, transfer_time);
     DCHECK_GE(bandwidth_.ToBitsPerSecond(),
               sender->last_transfer_bandwidth.ToBitsPerSecond());
     for (vector<Transfer>::iterator it = pending_transfers_.begin();
          it != pending_transfers_.end(); ++it) {
       if (transfer == &(*it)) {
@@ skipping 27 matching lines @@
         loss_correlation_ * std::numeric_limits<uint64_t>::max() >
             simple_random_.RandUint64()) {
       packet_lost = true;
     }
     DVLOG(1) << "losing packet:" << sender->last_sent
              << " name:" << transfer->name << " due to random loss.";
 
     // If the number of bytes in flight are less than the bdp, there's
     // no buffering delay.  Bytes lost from the buffer are not counted.
     QuicByteCount bdp = bandwidth_.ToBytesPerPeriod(rtt_);
-    QuicTime ack_time = clock_->Now().Add(rtt_).Add(sender->additional_rtt);
+    QuicTime ack_time = clock_->Now() + rtt_ + sender->additional_rtt;
     if (kPacketSize > bdp) {
-      ack_time = ack_time.Add(bandwidth_.TransferTime(kPacketSize - bdp));
+      ack_time = ack_time + bandwidth_.TransferTime(kPacketSize - bdp);
     }
     QuicTime queue_ack_time = sent_packets_.empty()
                                   ? QuicTime::Zero()
-                                  : sent_packets_.back().ack_time.Add(
-                                        bandwidth_.TransferTime(kPacketSize));
+                                  : sent_packets_.back().ack_time +
+                                        bandwidth_.TransferTime(kPacketSize);
     ack_time = QuicTime::Max(ack_time, queue_ack_time);
     sent_packets_.push_back(SentPacket(sender->last_sent, clock_->Now(),
                                        ack_time, packet_lost, transfer));
   } else {
     DVLOG(1) << "losing packet:" << sender->last_sent
              << " name:" << transfer->name << " because the buffer was full.";
   }
   transfer->bytes_in_flight += kPacketSize;
 }
 
 }  // namespace net