net/quic/congestion_control/inter_arrival_state_machine.h

// Copyright (c) 2013 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.

// State machine for congestion control. The state is updated by calls from
// other modules as they detect events, or decide on taking specific actions.
// Events include things like packet loss, or growing delay, while decisions
// include decisions to increase or decrease bitrates.
// This class should be called for every event and decision made by the
// congestion control, this class will coalesce all calls relative to the
// smoothed RTT.

#ifndef NET_QUIC_CONGESTION_CONTROL_INTER_ARRIVAL_STATE_MACHINE_H_
#define NET_QUIC_CONGESTION_CONTROL_INTER_ARRIVAL_STATE_MACHINE_H_

#include "net/base/net_export.h"
#include "net/quic/quic_clock.h"
#include "net/quic/quic_time.h"

namespace net {

//  State transition diagram.
//
//                     kInterArrivalStatePacketLoss
//                                   |
//                       kInterArrivalStateStable
//                                   |
//                       kInterArrivalStateDelay
//                           |              |
//  kInterArrivalStateCompetingFlow -> kInterArrivalStateCompetingTcpFLow

enum NET_EXPORT_PRIVATE InterArrivalState {
  // We are on a network with a delay that is too small to be reliably detected,
  // such as a local ethernet.
  kInterArrivalStatePacketLoss = 1,
  // We are on an underutilized network operating with low delay and low loss.
  kInterArrivalStateStable = 2,
  // We are on a network where we can detect delay changes and suffer only
  // low loss. Nothing indicates that we are competing with another flow.
  kInterArrivalStateDelay = 3,
  // We are on a network where we can detect delay changes and suffer only
  // low loss. We have indications that we are compete with another flow.
  kInterArrivalStateCompetingFlow = 4,
  // We are on a network where we can detect delay changes, however we suffer
  // packet loss due to sharing the bottleneck link with another flow, which is
  // most likely a TCP flow.
  kInterArrivalStateCompetingTcpFLow = 5,
};

class NET_EXPORT_PRIVATE InterArrivalStateMachine {
 public:
  explicit InterArrivalStateMachine(const QuicClock* clock);

  InterArrivalState GetInterArrivalState();

  // Inter arrival congestion control decided to increase bitrate.
  void IncreaseBitrateDecision();

  // Inter arrival congestion control decided to decrease bitrate.
  void DecreaseBitrateDecision();

  // Estimated smoothed round trip time.
  // This should be called whenever the smoothed RTT estimate is updated.
  void set_rtt(QuicTime::Delta rtt);

  // This method is called when a packet loss was reported.
  bool PacketLossEvent();

  // This method is called when we believe that packet transit delay is
  // increasing, presumably due to a growing queue along the path.
  bool IncreasingDelayEvent();

 private:
  const QuicClock* clock_;
  InterArrivalState current_state_;
  QuicTime::Delta smoothed_rtt_;

  int decrease_event_count_;
  QuicTime last_decrease_event_;

  int increase_event_count_;
  QuicTime last_increase_event_;

  int loss_event_count_;
  QuicTime last_loss_event_;

  int delay_event_count_;
  QuicTime last_delay_event_;

  DISALLOW_COPY_AND_ASSIGN(InterArrivalStateMachine);
};

}  // namespace net
#endif  // NET_QUIC_CONGESTION_CONTROL_INTER_ARRIVAL_STATE_MACHINE_H_