1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // State machine for congestion control. The state is updated by calls from 6 // other modules as they detect events, or decide on taking specific actions. 7 // Events include things like packet loss, or growing delay, while decisions 8 // include decisions to increase or decrease bitrates. 9 // This class should be called for every event and decision made by the 10 // congestion control, this class will coalesce all calls relative to the 11 // smoothed RTT. 12 13 #ifndef NET_QUIC_CONGESTION_CONTROL_INTER_ARRIVAL_STATE_MACHINE_H_ 14 #define NET_QUIC_CONGESTION_CONTROL_INTER_ARRIVAL_STATE_MACHINE_H_ 15 16 #include "net/base/net_export.h" 17 #include "net/quic/quic_clock.h" 18 #include "net/quic/quic_time.h" 19 20 namespace net { 21 22 // State transition diagram. 23 // 24 // kInterArrivalStatePacketLoss 25 // | 26 // kInterArrivalStateStable 27 // | 28 // kInterArrivalStateDelay 29 // | | 30 // kInterArrivalStateCompetingFlow -> kInterArrivalStateCompetingTcpFLow 31 32 enum NET_EXPORT_PRIVATE InterArrivalState { 33 // We are on a network with a delay that is too small to be reliably detected, 34 // such as a local ethernet. 35 kInterArrivalStatePacketLoss = 1, 36 // We are on an underutilized network operating with low delay and low loss. 37 kInterArrivalStateStable = 2, 38 // We are on a network where we can detect delay changes and suffer only 39 // low loss. Nothing indicates that we are competing with another flow. 40 kInterArrivalStateDelay = 3, 41 // We are on a network where we can detect delay changes and suffer only 42 // low loss. We have indications that we are compete with another flow. 43 kInterArrivalStateCompetingFlow = 4, 44 // We are on a network where we can detect delay changes, however we suffer 45 // packet loss due to sharing the bottleneck link with another flow, which is 46 // most likely a TCP flow. 47 kInterArrivalStateCompetingTcpFLow = 5, 48 }; 49 50 class NET_EXPORT_PRIVATE InterArrivalStateMachine { 51 public: 52 explicit InterArrivalStateMachine(const QuicClock* clock); 53 54 InterArrivalState GetInterArrivalState(); 55 56 // Inter arrival congestion control decided to increase bitrate. 57 void IncreaseBitrateDecision(); 58 59 // Inter arrival congestion control decided to decrease bitrate. 60 void DecreaseBitrateDecision(); 61 62 // Estimated smoothed round trip time. 63 // This should be called whenever the smoothed RTT estimate is updated. 64 void set_rtt(QuicTime::Delta rtt); 65 66 // This method is called when a packet loss was reported. 67 bool PacketLossEvent(); 68 69 // This method is called when we believe that packet transit delay is 70 // increasing, presumably due to a growing queue along the path. 71 bool IncreasingDelayEvent(); 72 73 private: 74 const QuicClock* clock_; 75 InterArrivalState current_state_; 76 QuicTime::Delta smoothed_rtt_; 77 78 int decrease_event_count_; 79 QuicTime last_decrease_event_; 80 81 int increase_event_count_; 82 QuicTime last_increase_event_; 83 84 int loss_event_count_; 85 QuicTime last_loss_event_; 86 87 int delay_event_count_; 88 QuicTime last_delay_event_; 89 90 DISALLOW_COPY_AND_ASSIGN(InterArrivalStateMachine); 91 }; 92 93 } // namespace net 94 #endif // NET_QUIC_CONGESTION_CONTROL_INTER_ARRIVAL_STATE_MACHINE_H_ 95